Add files using upload-large-folder tool

.gitattributes

@@ -181,3 +181,4 @@ parrot/lib/python3.10/site-packages/torchvision/image.so filter=lfs diff=lfs mer
 parrot/lib/python3.10/site-packages/pillow.libs/libpng16-58efbb84.so.16.43.0 filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libsqlite3.so.0.8.6 filter=lfs diff=lfs merge=lfs -text
 parrot/bin/sqlite3 filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libsqlite3.so filter=lfs diff=lfs merge=lfs -text

parrot/lib/libsqlite3.so

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

parrot/lib/python3.10/site-packages/deepspeed/inference/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+from .v2 import RaggedInferenceEngineConfig, DeepSpeedTPConfig
+from .v2.engine_v2 import InferenceEngineV2
+from .v2 import build_hf_engine, build_engine_from_ds_checkpoint

parrot/lib/python3.10/site-packages/deepspeed/inference/config.py

@@ -0,0 +1,304 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+import deepspeed
+from deepspeed.pydantic_v1 import Field, validator
+from deepspeed.runtime.config_utils import DeepSpeedConfigModel
+from deepspeed.runtime.zero.config import DeepSpeedZeroConfig
+from typing import Dict, Union
+from enum import Enum
+
+
+class DtypeEnum(Enum):
+    # The torch dtype must always be the first value (so we return torch.dtype)
+    fp16 = torch.float16, "torch.float16", "fp16", "float16", "half"
+    fp32 = torch.float32, "torch.float32", "fp32", "float32", "float"
+    bf16 = torch.bfloat16, "torch.bfloat16", "bf16", "bfloat16", "bfloat"
+    int8 = torch.int8, "torch.int8", "int8"
+
+    # Copied from https://stackoverflow.com/a/43210118
+    # Allows us to use multiple values for each Enum index and returns first
+    # listed value when Enum is called
+    def __new__(cls, *values):
+        obj = object.__new__(cls)
+        # first value is canonical value
+        obj._value_ = values[0]
+        for other_value in values[1:]:
+            cls._value2member_map_[other_value] = obj
+        obj._all_values = values
+        return obj
+
+    def __repr__(self):
+        return "<%s.%s: %s>" % (
+            self.__class__.__name__,
+            self._name_,
+            ", ".join([repr(v) for v in self._all_values]),
+        )
+
+
+class MoETypeEnum(str, Enum):
+    residual = "residual"
+    standard = "standard"
+
+
+class DeepSpeedTPConfig(DeepSpeedConfigModel):
+    """ Configure tensor parallelism settings """
+
+    enabled: bool = True
+    """ Turn tensor parallelism on/off. """
+
+    tp_size: int = 1
+    """ Number of devices to split the model across using tensor parallelism. """
+
+    mpu: object = None
+    """
+    A model parallelism unit object that implements
+    ``get_{model,data}_parallel_{rank,group,world_size}()``.
+    """
+
+    tp_group: object = None
+
+
+class DeepSpeedMoEConfig(DeepSpeedConfigModel):
+    """ Sets parameters for MoE """
+
+    enabled: bool = True
+    ep_size: int = 1
+    """
+    The expert-parallelism size which is used for partitioning the experts
+    across the GPUs in the expert-parallel group.
+    """
+
+    moe_experts: list = Field([1], alias="num_experts")
+    """ The global number of experts used in an MoE layer. """
+
+    type: MoETypeEnum = MoETypeEnum.standard
+    """
+    Specify the type of MoE layer. We have two types of MoE layer: 'Standard'
+    and 'Residual'.
+    """
+
+    ep_mp_group: object = None
+    ep_group: object = Field(None, alias="expert_group")
+
+
+class QuantTypeEnum(str, Enum):
+    asym = "asymmetric"
+    sym = "symmetric"
+
+
+class BaseQuantConfig(DeepSpeedConfigModel):
+    enabled = True
+    num_bits = 8
+    q_type: QuantTypeEnum = QuantTypeEnum.sym
+    q_groups: int = 1
+
+
+class WeightQuantConfig(BaseQuantConfig):
+    enabled = True
+    quantized_initialization: Dict = {}
+    post_init_quant: Dict = {}
+
+
+class ActivationQuantConfig(BaseQuantConfig):
+    enabled = True
+
+
+class QKVQuantConfig(DeepSpeedConfigModel):
+    enabled = True
+
+
+class QuantizationConfig(DeepSpeedConfigModel):
+    enabled: bool = True
+    activation: ActivationQuantConfig = ActivationQuantConfig()
+    weight: WeightQuantConfig = WeightQuantConfig()
+    qkv: QKVQuantConfig = QKVQuantConfig()
+
+
+# todo: brainstorm on how to do ckpt loading for DS inference
+class InferenceCheckpointConfig(DeepSpeedConfigModel):
+    checkpoint_dir: str = None
+    save_mp_checkpoint_path: str = None
+    base_dir: str = None
+
+
+class DeepSpeedInferenceConfig(DeepSpeedConfigModel):
+    """ Sets parameters for DeepSpeed Inference Engine. """
+
+    replace_with_kernel_inject: bool = Field(False, alias="kernel_inject")
+    """
+    Set to true to inject inference kernels for models such as, Bert, GPT2,
+    GPT-Neo and GPT-J.  Otherwise, the injection_dict provides the names of two
+    linear layers as a tuple:
+    `(attention_output projection, transformer output projection)`
+    """
+
+    dtype: DtypeEnum = torch.float16
+    """
+    Desired model data type, will convert model to this type.
+    Supported target types: `torch.half`, `torch.int8`, `torch.float`
+    """
+
+    tensor_parallel: DeepSpeedTPConfig = Field({}, alias="tp")
+    """
+    Configuration for tensor parallelism used to split the model across several
+    GPUs. Expects a dictionary containing values for :any:`DeepSpeedTPConfig`.
+    """
+
+    enable_cuda_graph: bool = False
+    """
+    Use this flag for capturing the CUDA-Graph of the inference ops, so that it
+    can run faster using the graph replay method.
+    """
+
+    use_triton: bool = False
+    """
+    Use this flag to use triton kernels for inference ops.
+    """
+
+    triton_autotune: bool = False
+    """
+    Use this flag to enable triton autotuning.
+    Turning it on is better for performance but increase the 1st runtime for
+    autotuning.
+    """
+
+    zero: DeepSpeedZeroConfig = {}
+    """
+    ZeRO configuration to use with the Inference Engine. Expects a dictionary
+    containing values for :any:`DeepSpeedZeroConfig`.
+    """
+
+    triangular_masking: bool = Field(True, alias="tm")
+    """
+    Controls the type of masking for attention scores in transformer layer.
+    Note that the masking is application specific.
+    """
+
+    moe: Union[bool, DeepSpeedMoEConfig] = {}
+    """
+    Specify if the type of Transformer is MoE. Expects a dictionary containing
+    values for :any:`DeepSpeedMoEConfig`.
+    """
+
+    quant: QuantizationConfig = {}
+    """
+    NOTE: only works for int8 dtype.
+    Quantization settings used for quantizing your model using the MoQ.  The
+    setting can be one element or a tuple. If one value is passed in, we
+    consider it as the number of groups used in quantization. A tuple is passed
+    in if we want to mention that there is extra-grouping for the MLP part of a
+    Transformer layer (e.g. (True, 8) shows we quantize the model using 8
+    groups for all the network except the MLP part that we use 8 extra
+    grouping). Expects a dictionary containing values for
+    :any:`QuantizationConfig`.
+    """
+
+    #todo: refactor the following 3 into the new checkpoint_config
+    checkpoint: Union[str, Dict] = None
+    """
+    Path to deepspeed compatible checkpoint or path to JSON with load policy.
+    """
+
+    base_dir: str = ""
+    """
+    This shows the root directory under which all the checkpoint files exists.
+    This can be passed through the json config too.
+    """
+
+    set_empty_params: bool = False
+    """
+    specifying whether the inference-module is created with empty or real Tensor
+    """
+
+    save_mp_checkpoint_path: str = None
+    """
+    The path for which we want to save the loaded model with a checkpoint. This
+    feature is used for adjusting the parallelism degree to help alleviate the
+    model loading overhead. It does not save any new checkpoint if no path is
+    passed.
+    """
+
+    checkpoint_config: InferenceCheckpointConfig = Field({}, alias="ckpt_config")
+    """
+    TODO: Add docs. Expects a dictionary containing values for
+    :any:`InferenceCheckpointConfig`.
+    """
+
+    return_tuple: bool = True
+    """
+    Specify whether or not the transformer layers need to return a tuple or a
+    Tensor.
+    """
+
+    training_mp_size: int = 1
+    """
+    If loading a checkpoint this is the mp size that it was trained with, it
+    may be different than what the mp size that you want to use during
+    inference.
+    """
+
+    replace_method: str = Field(
+        "auto",
+        deprecated=True,
+        deprecated_msg="This parameter is no longer needed, please remove from your call to DeepSpeed-inference")
+
+    injection_policy: Dict = Field(None, alias="injection_dict")
+    """
+    Dictionary mapping a client nn.Module to its corresponding injection
+    policy. e.g., `{BertLayer : deepspeed.inference.HFBertLayerPolicy}`
+    """
+
+    injection_policy_tuple: tuple = None
+    """ TODO: Add docs """
+
+    config: Dict = Field(None, alias="args")  # todo: really no need for this field if we can refactor
+
+    max_out_tokens: int = Field(1024, alias="max_tokens")
+    """
+    This argument shows the maximum number of tokens inference-engine can work
+    with, including the input and output tokens. Please consider increasing it
+    to the required token-length required for your use-case.
+    """
+
+    min_out_tokens: int = Field(1, alias="min_tokens")
+    """
+    This argument communicates to the runtime the minimum number of tokens you
+    expect you will need to generate. This will cause the runtime to error
+    if it unable to provide this and provide context on the memory pressure
+    rather than seg-faulting or providing corrupted output.
+    """
+
+    transposed_mode: bool = Field(False, alias="transposed_mode")
+
+    mp_size: int = Field(1, deprecated=True, new_param="tensor_parallel.tp_size")
+    """
+    Desired model parallel size, default is 1 meaning no model parallelism.
+    Deprecated, please use the ``tensor_parallel` config to control model
+    parallelism.
+    """
+    mpu: object = Field(None, deprecated=True, new_param="tensor_parallel.mpu")
+    ep_size: int = Field(1, deprecated=True, new_param="moe.ep_size")
+    ep_group: object = Field(None, alias="expert_group", deprecated=True, new_param="moe.ep_group")
+    ep_mp_group: object = Field(None, alias="expert_mp_group", deprecated=True, new_param="moe.ep_mp_group")
+    moe_experts: list = Field([1], deprecated=True, new_param="moe.moe_experts")
+    moe_type: MoETypeEnum = Field(MoETypeEnum.standard, deprecated=True, new_param="moe.type")
+
+    @validator("moe")
+    def moe_backward_compat(cls, field_value, values):
+        if isinstance(field_value, bool):
+            return DeepSpeedMoEConfig(moe=field_value)
+        return field_value
+
+    @validator("use_triton")
+    def has_triton(cls, field_value, values):
+        if field_value and not deepspeed.HAS_TRITON:
+            raise ValueError('Triton needs to be installed to use deepspeed with triton kernels')
+        return field_value
+
+    class Config:
+        # Get the str representation of the datatype for serialization
+        json_encoders = {torch.dtype: lambda x: str(x)}

parrot/lib/python3.10/site-packages/deepspeed/inference/engine.py

@@ -0,0 +1,636 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+import time
+import os
+from deepspeed import comm as dist
+from deepspeed.utils.logging import log_dist
+
+from torch.nn.modules import Module
+from packaging import version as pkg_version
+from deepspeed.runtime.checkpoint_engine.torch_checkpoint_engine import TorchCheckpointEngine
+from deepspeed.utils.timer import SynchronizedWallClockTimer
+
+from ..runtime.state_dict_factory import SDLoaderFactory
+from ..runtime.weight_quantizer import WeightQuantization
+from ..module_inject import replace_transformer_layer, generic_injection
+from ..comm.comm import init_distributed
+from ..pipe import PipelineModule
+from ..moe.utils import has_moe_layers
+from ..module_inject import LinearAllreduce, LinearLayer, Normalize, ReplaceWithTensorSlicing
+from deepspeed.accelerator import get_accelerator
+from ..module_inject.policy import TransformerPolicy
+from ..module_inject.auto_tp import AutoTP
+
+from ..module_inject.replace_policy import generic_policies
+from ..module_inject.auto_tp_model_utils import build_bloom_alibi_tensor, build_mpt_atten_bias_tensor, build_mpt_alibi_tensor, get_alibi_mask
+from ..ops.transformer.inference.ds_attention import DeepSpeedSelfAttention
+from ..model_implementations.transformers.ds_transformer import DeepSpeedTransformerInference
+
+DS_INFERENCE_ENABLED = False
+from torch import nn
+
+INFERENCE_MODEL_TIMER = "model-forward-inference"
+
+
+class InferenceEngine(Module):
+    inference_mp_group = None
+    inference_ep_group = None
+    expert_mp_group = None
+
+    def __init__(self, model, config):
+        """
+        Args:
+            model: torch.nn.Module
+            config: DeepSpeedInferenceConfig
+        """
+        global DS_INFERENCE_ENABLED
+        DS_INFERENCE_ENABLED = True
+
+        super().__init__()
+
+        # Have to import here because inference_module is a global, but python
+        # globals only work at the module level and will not be updated unless
+        # we import it each time we init a new inference engine.
+        from ..model_implementations.transformers.ds_transformer import inference_module
+        if inference_module is not None:
+            self.destroy()
+
+        self.module = model
+        self._config = config
+
+        self._get_model_config_generate(config)  # keep for weird backward compatibility
+
+        # patch model generate with ours if model uses it
+        if hasattr(self.module, "generate"):
+            self.generate = self._generate
+
+        if hasattr(self.module, "config"):
+            TransformerPolicy.hf_model_config = self.module.config
+
+        if config.dtype == torch.half and not get_accelerator().is_fp16_supported():
+            raise ValueError("Type fp16 is not supported.")
+
+        # todo: keep this self.injection_dict because we don't use to change config.injection_policy API
+        # todo: this will get changed when Molly's PR on auto injection dict is merged
+        self.injection_dict = config.injection_policy
+
+        # todo: refactor the mp_group and mp_size related in the next refactor
+        self.mp_group = config.tensor_parallel.tp_group
+        self.mpu = config.tensor_parallel.mpu
+
+        #self._validate_args(self.mpu, config.replace_with_kernel_inject)
+        self.quantize_merge_count = 1
+        self.quantization_scales = None
+
+        # these are not needed in the config as we are creating them ourselves in the inference engine
+        self.ep_group = None  # config.moe.ep_group
+        self.expert_mp_group = None  # config.moe.ep_mp_group
+
+        self.cuda_graph_created = False
+        self.checkpoint_engine = TorchCheckpointEngine()
+        quantization_setting = None
+        self._init_quantization_setting(
+            quantization_setting)  # todo: update with the new quant config for weight quant
+        self.model_profile_enabled = False
+        self._model_times = []
+
+        if not self.injection_dict and config.replace_with_kernel_inject:
+            # This is a hack to remove the prepare_mask function on HF side for BLOOM architecture
+            self.remove_mask_prepare_for_bloom()
+
+        if self.injection_dict or not config.replace_with_kernel_inject:
+            # This is a hack to redefine the alibi func due to TP
+            if config.tensor_parallel.tp_size > 1:
+                self.build_alibi_tensor()
+                self.build_attn_bias()
+
+        if get_accelerator().device_name() == 'cuda' and config.enable_cuda_graph:
+            assert pkg_version.parse(torch.__version__) >= pkg_version.parse("1.10"), \
+                "If you want to use cuda graph, please upgrade torch to at least v1.10"
+
+        # convert model to intended dtype
+        if config.dtype:
+            self._convert_to_dtype(config)
+
+        if self.mpu:
+            config.tensor_parallel.tp_size = dist.get_world_size(group=self.mpu.get_model_parallel_group())
+            self.mp_group = self.mpu.get_model_parallel_group()
+        elif config.tensor_parallel.tp_size > 1:
+            self._create_model_parallel_group(config)
+            config.tensor_parallel.tp_group = self.mp_group
+
+        if isinstance(self.module, torch.nn.Module):
+            moe, _ = has_moe_layers(self.module)
+        else:
+            moe = False
+
+        if moe and dist.get_world_size() > 1:
+            self._create_ep_parallel_group(config.moe.moe_experts)
+
+        # We only support three modes: 1) user specified policy for tensor-parallelism, 2) kernel injection (replace_with_kernel_inject), and 3) automatic tensor parallelism if tp_size > 1.
+        if self.injection_dict:
+            # 1. User specified Tensor Parallelism
+            assert not config.replace_with_kernel_inject, "Cannot use both user specified injection policy and kernel injection"
+            for client_module, injection_policy in self.injection_dict.items():
+
+                assert issubclass(client_module,
+                                  torch.nn.Module), f"{client_module} is not a subclass of torch.nn.Module"
+
+                # construct the tuple and pass that instead of a string or dict.
+                if isinstance(injection_policy, str):
+                    config.injection_policy_tuple = (injection_policy, )
+                else:
+                    config.injection_policy_tuple = injection_policy
+
+                layer_names = [name for name, _ in self.module.named_modules()]
+                for policy in config.injection_policy_tuple:
+                    if not any(name.endswith(policy) for name in layer_names):
+                        raise ValueError(f"Injection policy layer'{policy}' not valid.")
+
+                self._apply_injection_policy(config, client_module)
+        else:
+            if config.replace_with_kernel_inject:
+                # 2. DeepSpeed Kernel Injection
+                self._apply_injection_policy(config)
+            elif config.tensor_parallel.tp_size > 1:
+                # 3. Automatic Tensor Parallelism
+                parser_dict = AutoTP.tp_parser(model)
+                print("AutoTP: ", parser_dict)
+                for client_module, injection_policy in parser_dict:
+                    if isinstance(injection_policy, str):
+                        config.injection_policy_tuple = (injection_policy, )
+                    else:
+                        config.injection_policy_tuple = injection_policy
+                    self._apply_injection_policy(config, client_module)
+
+        device = get_accelerator().current_device_name()
+        # NOTE: This check assumes a Hugging Face hierarchy for the device type i.e. module.device.type
+        is_meta_device = hasattr(self.module, "device") and self.module.device.type == 'meta'
+        if is_meta_device:
+            self.module.to_empty(device=device)
+        else:
+            self.module.to(device)
+
+        if config.tensor_parallel.tp_size > 1:
+            _rng_state = get_accelerator().get_rng_state().to(get_accelerator().current_device_name())
+            dist.broadcast(_rng_state, 0)
+            get_accelerator().set_rng_state(_rng_state.cpu())
+
+        if config.tensor_parallel.tp_size > 1:
+            assert not config.enable_cuda_graph, "Cuda graph is not supported for model parallelism"
+
+        # Check if local CUDA graphs can be created in replacement modules
+        self.local_cuda_graph = self._local_cuda_graph_used(self.module)
+
+    def destroy(self):
+        # Have to import here because inference_module is a global, but python
+        # globals only work at the module level and will not be updated unless
+        # we import it each time we init a new inference engine.
+        from ..model_implementations.transformers.ds_transformer import inference_module
+        DeepSpeedTransformerInference.layer_id = 0
+        DeepSpeedSelfAttention.num_layers = 0
+        if inference_module is not None:
+            inference_module.release_workspace()
+            inference_module = None
+
+    def profile_model_time(self, use_cuda_events=True):
+        if not self.model_profile_enabled and not self._config.enable_cuda_graph:
+            self.module.register_forward_pre_hook(self._pre_forward_hook)
+            self.module.register_forward_hook(self._post_forward_hook)
+        self.model_profile_enabled = True
+        self.use_cuda_events = use_cuda_events
+        if self.use_cuda_events:
+            self.timers = SynchronizedWallClockTimer()
+
+    # todo: remove this once all the config dicts are centralized from top level pydantic config
+    def _get_model_config_generate(self, config):
+        # this is being passed to replace_transformer_layer(config=self.user_model_config_dict)
+        self.config = getattr(self.module, 'config', None) if config.config is None else config.config
+
+    def remove_mask_prepare_for_bloom(self):
+        if hasattr(self.module, 'transformer'):
+            if hasattr(self.module.transformer, '_prepare_attn_mask'):
+                self.module.transformer._prepare_attn_mask = lambda attention_mask, *args, **kwargs: attention_mask
+
+    def build_alibi_tensor(self):
+        if hasattr(self.module, 'transformer'):
+            if hasattr(self.module.transformer, 'build_alibi_tensor'):
+                self.module.transformer.build_alibi_tensor = build_bloom_alibi_tensor
+            if hasattr(self.module.transformer, 'build_mpt_alibi_tensor'):
+                self.module.transformer.build_mpt_alibi_tensor_orig = self.module.transformer.build_mpt_alibi_tensor
+                self.module.transformer.__class__.build_mpt_alibi_tensor = build_mpt_alibi_tensor
+        if hasattr(self.module, 'model'):
+            if hasattr(self.module.model, 'get_alibi_mask'):
+                self.module.model.get_alibi_mask_orig = self.module.model.get_alibi_mask
+                self.module.model.__class__.get_alibi_mask = get_alibi_mask
+
+    def build_attn_bias(self):
+        if hasattr(self.module, 'transformer'):
+            if hasattr(self.module.transformer, '_attn_bias'):
+                self.module.transformer._attn_bias_orig = self.module.transformer._attn_bias
+                self.module.transformer.__class__._attn_bias = build_mpt_atten_bias_tensor
+
+    def _pre_forward_hook(self, module, *inputs, **kwargs):
+        if self.use_cuda_events:
+            self.timers(INFERENCE_MODEL_TIMER).start()
+        else:
+            get_accelerator().synchronize()
+            self._start = time.time()
+
+    def _post_forward_hook(self, module, input, output):
+        if self.use_cuda_events:
+            self.timers(INFERENCE_MODEL_TIMER).stop()
+            elapsed_time = self.timers(INFERENCE_MODEL_TIMER).elapsed(reset=True)
+        else:
+            get_accelerator().synchronize()
+            self._end = time.time()
+            elapsed_time = (self._end - self._start) * 1e3  # convert seconds to ms
+        self._model_times.append(elapsed_time)
+
+    def _create_model_parallel_group(self, config):
+        # Call the init process
+        if InferenceEngine.inference_mp_group is None:
+            init_distributed()
+            local_rank = int(os.getenv('LOCAL_RANK', '0'))
+            get_accelerator().set_device(local_rank)
+
+            ranks = [i for i in range(config.tensor_parallel.tp_size)]
+            self.mp_group = dist.new_group(ranks)
+            InferenceEngine.inference_mp_group = self.mp_group
+        else:
+            self.mp_group = InferenceEngine.inference_mp_group
+
+    def _create_ep_parallel_group(self, moe_experts):
+        # Call the init process
+        self.ep_group = {}
+        self.expert_mp_group = {}
+        moe_experts = moe_experts if type(moe_experts) is list else [moe_experts]
+        for e in moe_experts:
+            self.ep_group.update({e: None})
+            self.expert_mp_group.update({e: None})
+        for moe_ep_size in self.ep_group.keys():
+            num_ep_groups = dist.get_world_size() // moe_ep_size
+            for i in range(num_ep_groups):
+                ep_cnt = i * moe_ep_size
+                size = dist.get_world_size() if moe_ep_size > dist.get_world_size() else moe_ep_size
+                ranks = list(range(ep_cnt, ep_cnt + size))
+                _ep_group = dist.new_group(ranks)
+                if dist.get_rank() in ranks:
+                    self.ep_group.update({moe_ep_size: _ep_group})
+
+            if dist.get_world_size() > moe_ep_size:
+                num_expert_mp_groups = dist.get_world_size() // num_ep_groups
+                expert_mp_size = dist.get_world_size() // moe_ep_size
+                for i in range(num_expert_mp_groups):
+                    expert_mp_comm_ranks = [i + nr * moe_ep_size for nr in range(expert_mp_size)]
+                    _expert_mp_group = dist.new_group(expert_mp_comm_ranks)
+                    if dist.get_rank() in expert_mp_comm_ranks:
+                        self.expert_mp_group.update({moe_ep_size: _expert_mp_group})
+
+    def _init_quantization_setting(self, quantization_setting):
+        self.quantize_bits = 8
+        self.mlp_extra_grouping = False
+        self.quantize_groups = 1
+        if type(quantization_setting) is tuple:
+            self.mlp_extra_grouping, \
+            self.quantize_groups = quantization_setting
+        elif quantization_setting is not None:
+            self.quantize_groups = quantization_setting
+        log_dist(
+            f"quantize_bits = {self.quantize_bits} "
+            f"mlp_extra_grouping = {self.mlp_extra_grouping}, "
+            f"quantize_groups = {self.quantize_groups}", [0])
+
+    # TODO: remove this function and add this functionality to pydantic config checking
+    def _validate_args(self, mpu, replace_with_kernel_inject):
+        # TODO: to support SD pipeline we need to avoid this check for now
+        if replace_with_kernel_inject and not isinstance(self.module, Module):
+            raise ValueError(f"model must be a torch.nn.Module, got {type(self.module)}")
+        if not isinstance(self._config.tensor_parallel.tp_size, int) or self._config.tensor_parallel.tp_size < 1:
+            raise ValueError(f"mp_size must be an int >= 1, got {self._config.tensor_parallel.tp_size}")
+
+        if mpu:
+            methods = ["get_model_parallel_group", "get_data_parallel_group"]
+            for method in methods:
+                if not hasattr(mpu, method):
+                    raise ValueError(f"mpu is missing {method}")
+        if self._config.checkpoint is not None and not isinstance(self._config.checkpoint, (str, dict)):
+            raise ValueError(f"checkpoint must be None, str or dict, got {type(self._config.checkpoint)}")
+
+        supported_dtypes = [None, torch.half, torch.int8, torch.float]
+        if self._config.dtype not in supported_dtypes:
+            raise ValueError(f"{self._config.dtype} not supported, valid dtype: {supported_dtypes}")
+
+        if self.injection_dict is not None and not isinstance(self.injection_dict, dict):
+            raise ValueError(f"injection_dict must be None or a dict, got: {self.injection_dict}")
+
+    def load_model_with_checkpoint(self, r_module):
+        self.mp_replace = ReplaceWithTensorSlicing(
+            mp_group=self.mp_group, mp_size=self._config.tensor_parallel.tp_size)  #, out_dim=0, in_dim=1)
+        error_msgs = []
+
+        def load(module, state_dict, prefix):
+            args = (state_dict, prefix, {}, True, [], [], error_msgs)
+            if hasattr(module, 'weight'):
+                if module.weight.data.is_meta:
+                    # meta tensor cannot be casted or copied to, so we need to replace it with a normal tensor here
+                    module.weight = torch.nn.parameter.Parameter(data=torch.empty_like(module.weight.data,
+                                                                                       device="cpu"),
+                                                                 requires_grad=module.weight.data.requires_grad)
+                if 'query_key_value' in prefix:
+                    module.weight = self.mp_replace.strided_copy(module.weight.data,
+                                                                 state_dict[prefix + 'weight'],
+                                                                 num_splits=3)
+                else:
+                    module.weight = self.mp_replace.copy(module.weight.data, state_dict[prefix + 'weight'])
+            else:
+                if module.norm.weight.data.is_meta:
+                    # meta tensor cannot be casted or copied to, so we need to replace it with a normal tensor here
+                    module.norm.weight = torch.nn.parameter.Parameter(
+                        data=torch.empty_like(module.norm.weight.data, device="cpu"),
+                        requires_grad=module.norm.weight.data.requires_grad)
+                module.norm.weight = self.mp_replace.copy(module.norm.weight.data, state_dict[prefix + 'weight'])
+            if prefix + 'bias' in self.key_list:
+                if hasattr(module, 'norm'):
+                    if module.norm.bias.data.is_meta:
+                        # meta tensor cannot be casted or copied to, so we need to replace it with a normal tensor here
+                        module.norm.bias = torch.nn.parameter.Parameter(
+                            data=torch.empty_like(module.norm.bias.data, device="cpu"),
+                            requires_grad=module.norm.bias.data.requires_grad)
+                    module.norm.bias = self.mp_replace.copy(module.norm.bias, state_dict[prefix + 'bias'])
+                else:
+                    if module.bias.data.is_meta:
+                        # meta tensor cannot be casted or copied to, so we need to replace it with a normal tensor here
+                        module.bias = torch.nn.parameter.Parameter(data=torch.empty_like(module.bias.data,
+                                                                                         device="cpu"),
+                                                                   requires_grad=module.bias.data.requires_grad)
+                    data = state_dict[prefix + 'bias']
+                    data = data.to(get_accelerator().current_device_name())
+                    module.bias = self.mp_replace.copy(module.bias, data)
+
+        layer_policies = {
+            nn.Linear: load,
+            nn.Embedding: load,
+            nn.LayerNorm: load,
+            LinearLayer: load,
+            LinearAllreduce: load
+        }
+
+        def load_module_recursive(module, prefix='', level=0):
+            for name, child in module.named_children():
+                if child.__class__ in layer_policies:
+                    checking_key = prefix + name + '.'
+                    if not any(checking_key in item for item in self.key_list):
+                        continue
+                    if len(list(child.parameters())) > 0 and list(child.parameters())[0].numel() == 0:
+                        if len(child.weight.ds_shape) == 1:
+                            child = Normalize(dim=child.weight.ds_shape[-1], dtype=child.weight.dtype, eps=child.eps)
+                            setattr(module, name, child)
+                    load(child, self.sd, prefix + name + '.')
+                else:
+                    load_module_recursive(child, prefix if level == 0 else prefix + name + '.', level + 1)
+
+        load_module_recursive(r_module)
+
+        embedding_weight = None
+
+        for n, p in r_module.named_parameters():
+            if "word_embeddings." in n or "embed_tokens." in n or "wte." in n:
+                embedding_weight = p
+        if embedding_weight is not None and hasattr(r_module, "lm_head") and hasattr(
+                r_module.lm_head, "weight") and r_module.lm_head.weight.is_meta:
+            r_module.lm_head.weight = embedding_weight
+
+    def _apply_injection_policy(self, config, client_module=None):
+        # client_module is only passed when using the injection_dict method.
+        checkpoint_dir = config.checkpoint
+        checkpoint = SDLoaderFactory.get_sd_loader_json(checkpoint_dir,
+                                                        self.checkpoint_engine) if checkpoint_dir is not None else None
+
+        generic_injection(self.module, dtype=config.dtype, enable_cuda_graph=config.enable_cuda_graph)
+
+        if isinstance(self.module, torch.nn.Module):
+            # config is our DeepSpeedInferenceConfig and self.config is the HF model config
+            replace_transformer_layer(client_module, self.module, checkpoint, config, self.config)
+
+    def _get_all_ckpt_names(self, checkpoints_path, tag):
+        ckpt_file_pattern = self._get_ckpt_name(checkpoints_path, tag, mp_placeholder="*")
+        import glob
+
+        ckpt_files = glob.glob(ckpt_file_pattern)
+        ckpt_files.sort()
+        return ckpt_files
+
+    def _get_ckpt_name(self, checkpoints_path, tag, mp_placeholder=None):
+        if mp_placeholder is not None:
+            mp_rank_str = mp_placeholder
+        else:
+            mp_rank = 0 if self.mpu is None else self.mpu.get_model_parallel_rank()
+            mp_rank_str = "{:02d}".format(mp_rank)
+
+        ckpt_name = os.path.join(
+            checkpoints_path,
+            "mp_rank_" + mp_rank_str + "_model_states.pt",
+        )
+        return ckpt_name
+
+    def _load_checkpoint(self, load_dir, load_module_strict=True, tag=None):
+        is_pipe_parallel = isinstance(self.module, PipelineModule)
+        if is_pipe_parallel:
+            raise RuntimeError('pipeline parallelism is currently not supported in inference.')
+        if not isinstance(load_dir, dict) and os.path.isdir(load_dir):
+            if tag is None:
+                latest_path = os.path.join(load_dir, "latest")
+                if os.path.isfile(latest_path):
+                    with open(latest_path, "r") as fd:
+                        tag = fd.read().strip()
+
+            ckpt_list = self._get_all_ckpt_names(load_dir, tag)
+            sd_loader = SDLoaderFactory.get_sd_loader(ckpt_list, self.checkpoint_engine)
+        else:
+            sd_loader = SDLoaderFactory.get_sd_loader_json(load_dir, self.checkpoint_engine)
+
+        checkpoint = sd_loader['checkpoints']
+
+        if type(checkpoint) is list:
+            self.sd = torch.load(checkpoint[0], map_location='cpu')
+            self.key_list = list(self.sd.keys())
+
+            self.load_model_with_checkpoint(self.module)
+
+            for i in range(1, len(checkpoint)):
+                if not dist.is_initialized() or dist.get_rank() == 0:
+                    print(f"loading checkpoint ({i})")
+                self.sd = torch.load(checkpoint[i], map_location=get_accelerator().device_name())
+                self.key_list = list(self.sd.keys())
+                self.load_model_with_checkpoint(self.module)
+        else:
+            mp_rank = 0 if self.mpu is None else self.mpu.get_model_parallel_rank()
+
+            load_path, checkpoint, quantize_config = sd_loader.load(self._config.tensor_parallel.tp_size,
+                                                                    mp_rank,
+                                                                    is_pipe_parallel=is_pipe_parallel,
+                                                                    quantize=(self._config.dtype is torch.int8),
+                                                                    quantize_groups=self.quantize_groups,
+                                                                    mlp_extra_grouping=self.mlp_extra_grouping)
+
+            self.quantization_scales, self.quantize_merge_count = quantize_config
+
+            moe, _ = has_moe_layers(self.module)
+            if moe:
+                from deepspeed.runtime.engine import DeepSpeedEngine
+                old_moe_load = False
+                if not isinstance(checkpoint['num_experts'], list):
+                    old_moe_load = True
+                DeepSpeedEngine.load_moe_state_dict(load_dir,
+                                                    tag,
+                                                    state_dict=checkpoint[self._choose_module_key(checkpoint)],
+                                                    old_moe_load=old_moe_load,
+                                                    model=self.module,
+                                                    mpu=self.mpu,
+                                                    checkpoint_engine=self.checkpoint_engine)
+
+            self.module.load_state_dict(state_dict=checkpoint[self._choose_module_key(checkpoint)],
+                                        strict=load_module_strict)
+
+    def _choose_module_key(self, sd):
+        assert not ('module' in sd
+                    and 'model' in sd), "checkpoint has both 'model' and 'module' keys, not sure how to proceed"
+        assert 'module' in sd or 'model' in sd, "checkpoint contains neither 'model' or 'module' keys, not sure how to proceed"
+        if 'module' in sd:
+            return 'module'
+        elif 'model' in sd:
+            return 'model'
+
+    def _convert_to_dtype(self, config):
+        if not isinstance(self.module, torch.nn.Module):
+            return
+
+        if False:  #config.dtype is torch.int8 and self.quantization_scales is None:
+            quantizer = WeightQuantization(mlp_extra_grouping=self.mlp_extra_grouping)
+            model, self.quantization_scales = quantizer.model_quantize(self.module, self.injection_dict,
+                                                                       self.quantize_bits, self.quantize_groups)
+        elif config.dtype == torch.half:
+            self.module.half()
+        elif config.dtype == torch.bfloat16:
+            self.module.bfloat16()
+        elif config.dtype == torch.float:
+            self.module.float()
+
+    def _create_cuda_graph(self, *inputs, **kwargs):
+        # warmup to create the workspace and cublas handle
+        cuda_stream = get_accelerator().Stream()
+        cuda_stream.wait_stream(get_accelerator().current_stream())
+        with get_accelerator().stream(cuda_stream):
+            for i in range(3):
+                ret = self.module(*inputs, **kwargs)
+        get_accelerator().current_stream().wait_stream(cuda_stream)
+
+        # create cuda_graph and assign static_inputs and static_outputs
+        self._cuda_graphs = get_accelerator().create_graph()
+        self.static_inputs = inputs
+        self.static_kwargs = kwargs
+
+        with get_accelerator().capture_to_graph(self._cuda_graphs):
+            self.static_output = self.module(*self.static_inputs, **self.static_kwargs)
+
+        self.cuda_graph_created = True
+
+    def _graph_replay(self, *inputs, **kwargs):
+        for i in range(len(inputs)):
+            if torch.is_tensor(inputs[i]):
+                self.static_inputs[i].copy_(inputs[i])
+        for k in kwargs:
+            if torch.is_tensor(kwargs[k]):
+                self.static_kwargs[k].copy_(kwargs[k])
+        get_accelerator().replay_graph(self._cuda_graphs)
+        return self.static_output
+
+    def model_times(self):
+        assert self.model_profile_enabled, "model profiling is not enabled"
+        model_times = self._model_times
+        if self._config.enable_cuda_graph and len(self._model_times) == 0:
+            raise ValueError("Model times are empty and cuda graph is enabled. If "
+                             "this is a GPT-style model this combo is not supported. If this is a "
+                             "BERT-style model this is a bug, please report it. "
+                             f"Model type is: {type(self.module)}")
+        self._model_times = []
+        return model_times
+
+    def _module_match(self, module):
+        for policy in generic_policies:
+            policy = policy()
+            if policy.match_replaced(module):
+                return True
+        return False
+
+    def _local_cuda_graph_used(self, module):
+        if isinstance(module, torch.nn.Module):
+            return False
+        else:
+            sub_module_cuda_graph = False
+            for name in module.__dict__.keys():
+                sub_module = getattr(module, name)
+
+                if self._module_match(sub_module) and hasattr(sub_module, "enable_cuda_graph"):
+                    sub_module_cuda_graph = True
+
+            return sub_module_cuda_graph
+
+    def forward(self, *inputs, **kwargs):
+        """Execute forward propagation
+
+        Arguments:
+            *inputs: Variable length input list
+            **kwargs: variable length keyword arguments
+        """
+        start = None
+        if self.model_profile_enabled and get_accelerator().device_name() == 'cuda' and self._config.enable_cuda_graph:
+            get_accelerator().synchronize()
+            start = time.time()
+
+        if get_accelerator().device_name() == 'cuda' and self._config.enable_cuda_graph and not self.local_cuda_graph:
+            if self.cuda_graph_created:
+                outputs = self._graph_replay(*inputs, **kwargs)
+            else:
+                self._create_cuda_graph(*inputs, **kwargs)
+                outputs = self._graph_replay(*inputs, **kwargs)
+
+        else:
+            outputs = self.module(*inputs, **kwargs)
+
+        if self.model_profile_enabled and self._config.enable_cuda_graph:
+            get_accelerator().synchronize()
+            duration = (time.time() - start) * 1e3  # convert seconds to ms
+            self._model_times.append(duration)
+
+        return outputs
+
+    def _generate(self, *inputs, **kwargs):
+        # Reset KV-cache at the beginning of generate
+        if hasattr(self.module, 'reset_cache'):
+            self.module.reset_cache()
+        num_beams = 1
+        if "generation_config" in kwargs:
+            gen_config = kwargs["generation_config"]
+            num_beams = getattr(gen_config, "num_beams", 1)
+        if "num_beams" in kwargs:
+            num_beams = kwargs["num_beams"]
+
+        if num_beams > 1:
+            raise NotImplementedError("DeepSpeed does not support `num_beams` > 1, if this is important to you please "
+                                      "add your request to: https://github.com/microsoft/DeepSpeed/issues/2506")
+
+        if ("input_ids" in kwargs) and (kwargs["input_ids"].dim() == 2):
+            for input_tensor in kwargs["input_ids"]:
+                tensor_length = input_tensor.shape[-1]
+                if tensor_length > self._config.max_out_tokens:
+                    raise RuntimeError(
+                        f"Input with size {tensor_length} exceeds maximum length of {self._config.max_out_tokens}. Please increase `max_tokens` in the DeepSpeed Inference Config."
+                    )
+
+        return self.module.generate(*inputs, **kwargs)

parrot/lib/python3.10/site-packages/deepspeed/inference/quantization/__init__.py

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

parrot/lib/python3.10/site-packages/deepspeed/inference/quantization/layers.py

@@ -0,0 +1,114 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from torch import nn
+from torch import Tensor
+from torch.nn import functional as F
+from .utils import Quantizer, DeQuantizer, concat_to_compat_param
+from typing import Tuple, Callable, Dict
+from deepspeed.runtime.zero import register_external_parameter
+
+quantized_weight_registry = {}
+is_zero3_enabled = False
+
+
+# deal with weight sharing
+def get_quantized_weight_wrapper(model, pre_quant_weight: nn.Parameter, quantize_weight_fn: Callable) -> nn.Parameter:
+    if id(pre_quant_weight) in quantized_weight_registry:
+        compat_tensor = quantized_weight_registry[id(pre_quant_weight)]
+        if is_zero3_enabled:
+            register_external_parameter(model, compat_tensor)
+
+        return quantized_weight_registry[id(pre_quant_weight)]
+    else:
+        quantized_weights, quant_scale, quant_min = quantize_weight_fn()
+        quantized_weight_registry[id(pre_quant_weight)] = concat_to_compat_param(quantized_weights, quant_scale,
+                                                                                 quant_min)
+        return quantized_weight_registry[id(pre_quant_weight)]
+
+
+def get_quantize_weight_fn(quantizer: Quantizer, pre_quant_weight: nn.Parameter) -> Callable:
+
+    def func() -> Tuple[nn.Parameter, Tensor, Tensor]:
+        quantized_weights, quant_scale, quant_min = quantizer.quantize(pre_quant_weight.data)
+        # A temporary hack as zero Zero3 assume all model weights has the same type. in all_gather_coalesced.get_only_unique_item
+        quantized_weights = quantized_weights.view(pre_quant_weight.dtype)
+        quant_scale = quant_scale.type(pre_quant_weight.dtype)
+        quant_min = quant_min.type(pre_quant_weight.dtype)
+        return quantized_weights, quant_scale, quant_min
+
+    return func
+
+
+class QuantizedLinear(nn.Linear):
+
+    def __init__(self, config: Dict, pre_quant_layer: nn.Linear) -> None:
+        super(QuantizedLinear, self).__init__(in_features=pre_quant_layer.in_features,
+                                              out_features=pre_quant_layer.out_features,
+                                              bias=pre_quant_layer.bias is not None,
+                                              device=pre_quant_layer.weight.device,
+                                              dtype=pre_quant_layer.weight.dtype)
+        self.config = config
+
+        self.quantizer = Quantizer(config=config)
+        self.bias = pre_quant_layer.bias
+        self.weight = get_quantized_weight_wrapper(self, pre_quant_layer.weight,
+                                                   get_quantize_weight_fn(self.quantizer, pre_quant_layer.weight))
+
+        self.weight.dequantizer = DeQuantizer(config, pre_quant_layer.weight.dtype)
+
+    def forward(self, input: Tensor) -> Tensor:
+        quantized_weight, quant_scale, quant_min = self.weight.deconcat(self.weight)
+        temp_dequantized_weight = self.weight.dequantizer.dequantize(quantized_weight.view(torch.uint8), quant_scale,
+                                                                     quant_min)
+
+        # !!! Do not use torch.functional.linear(input, temp_dequantized_weight, self.bias) here as in zero3 torch.functional.linear is
+        # replaced by LinearFunctionForZeroStage3. Which assume weight is non-temporary.
+        # If weight is temp buffer there will be memory leak.
+        return torch._C._nn.linear(input, temp_dequantized_weight, self.bias)
+
+
+class QuantizedEmbedding(nn.Embedding):
+
+    def __init__(self, config: Dict, pre_quant_layer: nn.Embedding) -> None:
+        super(QuantizedEmbedding, self).__init__(num_embeddings=pre_quant_layer.num_embeddings,
+                                                 embedding_dim=pre_quant_layer.embedding_dim,
+                                                 padding_idx=pre_quant_layer.padding_idx,
+                                                 max_norm=pre_quant_layer.max_norm,
+                                                 norm_type=pre_quant_layer.norm_type,
+                                                 scale_grad_by_freq=pre_quant_layer.scale_grad_by_freq,
+                                                 sparse=pre_quant_layer.sparse,
+                                                 _weight=pre_quant_layer.weight,
+                                                 device=pre_quant_layer.weight.device,
+                                                 dtype=pre_quant_layer.weight.dtype)
+
+        assert pre_quant_layer.max_norm is None, 'Not supported'
+        assert pre_quant_layer.norm_type == 2, 'Not supported'
+        assert pre_quant_layer.scale_grad_by_freq == False, 'Not supported'
+        assert pre_quant_layer.sparse == False, 'Not supported'
+
+        self.config = config
+        quantizer = Quantizer(config=config)
+
+        self.weight = get_quantized_weight_wrapper(self, pre_quant_layer.weight,
+                                                   get_quantize_weight_fn(quantizer, pre_quant_layer.weight))
+
+        self.weight.dequantizer = DeQuantizer(config, pre_quant_layer.weight.dtype)
+
+    def forward(self, input: Tensor) -> Tensor:
+        quantized_weight, quant_scale, quant_min = self.weight.deconcat(self.weight)
+        temp_dequantized_weight = self.weight.dequantizer.dequantize(quantized_weight.view(torch.uint8), quant_scale,
+                                                                     quant_min)
+
+        return F.embedding(input, temp_dequantized_weight, self.padding_idx, self.max_norm, self.norm_type,
+                           self.scale_grad_by_freq, self.sparse)
+
+
+QUANTIZATION_LAYER_MAPPINGS = {
+    nn.Linear: QuantizedLinear,
+    nn.Embedding: QuantizedEmbedding,
+}

parrot/lib/python3.10/site-packages/deepspeed/inference/quantization/quantization.py

@@ -0,0 +1,111 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+from torch import nn
+from typing import Dict
+import gc
+from deepspeed.inference.quantization import layers
+from .layers import QUANTIZATION_LAYER_MAPPINGS
+from .utils import get_AsyncPartitionedParameterSwapper, recursive_setattr
+from deepspeed.utils.logging import logger
+from collections import deque
+from transformers.utils.generic import ContextManagers
+from .quantization_context import QuantizationContext
+import contextlib
+
+
+def _init_group_wise_weight_quantization(model: nn.Module, ds_config: Dict) -> nn.Module:
+    """[Experimental] Apply group-wise weight quantization to model. Replace layers module according to config_list
+
+    Args:
+        model (nn.Module): A nn.Module
+        ds_config (Dict, optional): The ds_config dictionary. use None for non-deepspeed managed model.
+
+    Returns:
+        nn.Module: Quantized nn.Module
+    """
+
+    # global quantized_weight_registry
+
+    matched_module_list_by_key = {}
+    matched_module_count = 0
+
+    assert 'weight_quantization' in ds_config, 'Please provide quantization config in ds_config'
+    quantization_config = ds_config['weight_quantization']['post_init_quant']
+
+    # Return nvme swapper if exists, else return None.
+    # For nvme offloading we must use the same swapper here as model initialized.
+    nvme_swapper = get_AsyncPartitionedParameterSwapper(model)
+    is_zero3_enabled = 'zero_optimization' in ds_config and \
+            'stage' in ds_config['zero_optimization'] and \
+            ds_config['zero_optimization']['stage'] == 3
+    is_offloading_enabled = 'zero_optimization' in ds_config and \
+                            'offload_param' in ds_config['zero_optimization']
+
+    layers.is_zero3_enabled = is_zero3_enabled
+
+    context_mgr = ContextManagers([QuantizationContext(config_dict_or_path=ds_config, param_swapper=nvme_swapper)]) \
+                    if is_zero3_enabled else contextlib.suppress()
+    with context_mgr:
+        module_list = list(
+            filter(lambda named_module: type(named_module[1]) in QUANTIZATION_LAYER_MAPPINGS, model.named_modules()))
+
+        # Quantize small weight first then large.
+        if not is_offloading_enabled:
+            module_list.sort(key=lambda named_module: named_module[1].weight.ds_tensor.numel()
+                             if is_zero3_enabled else named_module[1].weight.numel())
+        module_list = deque(module_list)
+
+        while len(module_list) > 0:
+            # Use popleft to timely release module's memory of replaced module after each loop iteration
+            module_name, module = module_list.popleft()
+
+            matched_key = None
+            matched_quantization_config = None
+
+            for key, config in quantization_config.items():
+                if key in module_name:
+                    assert matched_key is None, f'{module_name} matched multiple quantization key word {matched_key} and {key}'
+                    matched_key = key
+                    matched_quantization_config = config
+
+            if matched_key is None:
+                continue
+
+            if is_zero3_enabled:
+                module.weight.all_gather()
+
+            assert module.weight.dtype == torch.float16, 'Model weight is expected in half.'
+
+            new_module = QUANTIZATION_LAYER_MAPPINGS[type(module)](matched_quantization_config, module)
+
+            if is_zero3_enabled:
+                module.weight.partition()
+
+            recursive_setattr(model, module_name, new_module)
+
+            if matched_key not in matched_module_list_by_key:
+                matched_module_list_by_key[matched_key] = []
+            matched_module_list_by_key[matched_key].append(module_name)
+            matched_module_count += 1
+
+            # Timely recycle memory to prevent OOM on large models
+            gc.collect()
+
+    # Clear registry after model construction.
+    layers.quantized_weight_registry.clear()
+
+    logger.info(
+        f'Group-wise weight quantization summary: convert {matched_module_count} node(s) to quantized implementation')
+    summary_str = '\n'
+
+    for key, module_list in matched_module_list_by_key.items():
+        summary_str += f'Key: {key}, matched modules:\n'
+        for module_name in module_list:
+            summary_str += f'\t{module_name}\n'
+    logger.info(summary_str)
+
+    return model

parrot/lib/python3.10/site-packages/deepspeed/inference/quantization/quantization_context.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from deepspeed.runtime.zero import partition_parameters
+from deepspeed.runtime.swap_tensor.partitioned_param_swapper import AsyncPartitionedParameterSwapper
+
+
+class QuantizationContext(partition_parameters.Init):
+
+    def __init__(self, config_dict_or_path, param_swapper: AsyncPartitionedParameterSwapper = None) -> None:
+        super().__init__(config_dict_or_path=config_dict_or_path, param_swapper=param_swapper)

parrot/lib/python3.10/site-packages/deepspeed/inference/quantization/utils.py

@@ -0,0 +1,288 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+import deepspeed
+from torch import Tensor
+from typing import Tuple
+import torch.nn as nn
+from typing import Dict, Callable, Union
+from deepspeed.accelerator import get_accelerator
+import functools
+
+device = get_accelerator().device_name() if get_accelerator().is_available() else 'cpu'
+
+quantizer_cuda_module = None
+
+
+def get_quantizer_cuda_module():
+    global quantizer_cuda_module
+    if quantizer_cuda_module is None:
+        quantizer_cuda_module = deepspeed.ops.op_builder.QuantizerBuilder().load()
+    return quantizer_cuda_module
+
+
+def tensor_clamp(tensor: Tensor, min, max) -> Tensor:
+    if tensor.device.type == 'cpu' and tensor.dtype == torch.float16:
+        # CPU does not support FP16 clamp
+        return tensor.to(dtype=torch.float32).clamp_(min, max).to(dtype=torch.float16)
+    else:
+        return tensor.clamp_(min, max)
+
+
+def tensor_round(tensor: Tensor) -> Tensor:
+    if tensor.device.type == 'cpu' and tensor.dtype == torch.float16:
+        # CPU does not support FP16 round
+        return tensor.to(dtype=torch.float32).round_().to(dtype=torch.float16)
+    else:
+        return tensor.round_()
+
+
+class Quantizer:
+
+    def __init__(self, config: Dict) -> None:
+        self.config = config
+        assert self.config['num_bits'] == 4 or self.config[
+            'num_bits'] == 8, 'Only INT4 and INT8 quantization is supported.'
+        assert self.config['symmetric'] == False, 'Only asymmetric quantization is supported at this moment.'
+
+    def quantize(self, tensor: Tensor) -> Tuple[Tensor, Tensor, Tensor]:
+        assert tensor.shape[self.config['group_dim']] % self.config['group_size'] == 0 \
+            , f'Tensor shape: {tensor.shape} quantization config {self.config}'
+
+        tensor = torch.clone(tensor)
+
+        shape = tensor.shape
+        num_groups = shape[self.config['group_dim']] // self.config['group_size']
+        new_shape = (shape[:self.config['group_dim']] + (num_groups, self.config['group_size']) +
+                     shape[self.config['group_dim'] + 1:])
+        tensor = tensor.view(new_shape)
+
+        quantized_tensor, scale, min_value = self._quantize_int8(tensor)
+        quantized_tensor = quantized_tensor.view(shape)
+
+        if self.config['num_bits'] == 4:
+            return self._compress_uint8_to_uint4(quantized_tensor), scale, min_value
+        if self.config['num_bits'] == 8:
+            return quantized_tensor, scale, min_value
+
+        assert False, 'Unsupported quantization bits {}'.format(self.config['num_bits'])
+
+    def _quantize_int8(self, tensor: Tensor) -> Tuple[Tensor, Tensor, Tensor]:
+        q_range = 2**self.config['num_bits'] - 1
+        min_value = tensor.amin(dim=self.config['group_dim'] + 1, keepdim=True)
+        max_value = tensor.amax(dim=self.config['group_dim'] + 1, keepdim=True)
+
+        scale = q_range / (max_value - min_value)
+
+        tensor = tensor.sub_(min_value).mul_(scale)
+        tensor = tensor_round(tensor_clamp(tensor, 0, q_range)).to(torch.uint8)
+        return tensor, scale, min_value
+
+    def _compress_uint8_to_uint4(self, tensor: Tensor) -> Tensor:
+        assert tensor.shape[-1] % 2 == 0
+
+        new_data_shape = list(tensor.shape)
+        new_data_shape[-1] = new_data_shape[-1] // 2
+
+        data = torch.empty(new_data_shape, dtype=torch.uint8, device=tensor.device)
+        data = torch.bitwise_or(tensor[..., 0::2].bitwise_left_shift(4), tensor[..., 1::2])
+
+        return data
+
+
+class DeQuantizer:
+
+    def __init__(self, config: Dict, dtype: torch.dtype) -> None:
+        self.config = config
+        self.dtype = dtype
+        assert self.config['num_bits'] == 4 or self.config[
+            'num_bits'] == 8, 'Only INT4 and INT8 quantization is supported.'
+        assert self.config['symmetric'] == False, 'Only asymmetric quantization is supported at this moment.'
+
+    def dequantize(self, tensor: Tensor, quant_scale: Tensor, quant_min: Tensor) -> Tensor:
+        # Use customized CUDA quantization kernel if possible.
+        if self.config['group_size'] % 8 == 0 and \
+                (self.config['num_bits'] == 4 or self.config['num_bits'] == 8) and \
+                self.config['group_dim'] == len(tensor.shape) - 1 and \
+                    self.dtype == torch.float16 and device == 'cuda':
+
+            last_dimension_size = self.config['group_size']
+            if self.config['num_bits'] == 4:
+                last_dimension_size = last_dimension_size // 2
+                quantized_tensor = get_quantizer_cuda_module().dequantize_int4_to_half_experimental(
+                    tensor.reshape(-1, last_dimension_size), quant_scale, quant_min,
+                    tensor.numel() // last_dimension_size, self.config['group_size'])
+                shape = list(tensor.shape)
+                shape[-1] = shape[-1] * 2
+            elif self.config['num_bits'] == 8:
+                # last_dimension_size = last_dimension_size // 2
+                quantized_tensor = get_quantizer_cuda_module().dequantize_int8_to_half_experimental(
+                    tensor.reshape(-1, last_dimension_size), quant_scale, quant_min,
+                    tensor.numel() // last_dimension_size, self.config['group_size'])
+                shape = list(tensor.shape)
+
+            return quantized_tensor.reshape(shape)
+
+        if self.config['num_bits'] == 4:
+            tensor = self._decompress_uint4_to_uint8(tensor)
+        elif self.config['num_bits'] != 8:
+            assert False, 'Unsupported quantization bits {}'.format(self.config['num_bits'])
+
+        shape = tensor.shape
+        num_groups = shape[self.config['group_dim']] // self.config['group_size']
+        new_shape = (shape[:self.config['group_dim']] + (num_groups, self.config['group_size']) +
+                     shape[self.config['group_dim'] + 1:])
+        tensor = tensor.view(new_shape)
+
+        dequantized_tensor = self._dequantize_int8(tensor, quant_scale, quant_min).view(shape)
+        return dequantized_tensor
+
+    def _dequantize_int8(self, tensor: Tensor, quant_scale: Tensor, quant_min: Tensor) -> Tensor:
+        assert tensor.dtype == torch.uint8
+        data = torch.zeros_like(tensor, dtype=self.dtype, device=tensor.device)
+        data = data.copy_(tensor)
+        data = data.div_(quant_scale).add_(quant_min)
+
+        return data
+
+    def _decompress_uint4_to_uint8(self, tensor: Tensor) -> Tensor:
+        new_data_shape = list(tensor.shape)
+        new_data_shape[-1] = new_data_shape[-1] * 2
+        data = torch.empty(new_data_shape, dtype=torch.uint8, device=tensor.device)
+        data[..., 0::2] = tensor.bitwise_right_shift(4)
+        data[..., 1::2] = tensor.bitwise_and(0xF)
+
+        return data
+
+
+def get_AsyncPartitionedParameterSwapper(model: nn.Module):
+    for param_name, param in model.named_parameters():
+        if hasattr(param, 'nvme_swapper') and param.nvme_swapper is not None:
+            return param.nvme_swapper
+    return None
+
+
+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 concat_to_compat_param(quantized_weight: Tensor,
+                           quant_scale: Tensor,
+                           quant_min: Tensor,
+                           return_param: bool = True) -> Union[nn.Parameter, Tensor]:
+    shape_wieght = quantized_weight.shape
+    shape_scale = quant_scale.shape
+    shape_min = quant_min.shape
+
+    quantized_weight = torch.flatten(quantized_weight)
+    quant_scale = torch.flatten(quant_scale)
+    quant_min = torch.flatten(quant_min)
+
+    def deconcat_individual_tensors(shape_wieght: torch.Size, shape_scale: torch.Size,
+                                    shape_min: torch.Size) -> Callable:
+
+        def fn(compat_tensor: nn.Parameter) -> Tuple[Tensor, Tensor, Tensor]:
+            weight = torch.narrow(compat_tensor, 0, 0, shape_wieght.numel()).view(shape_wieght)
+            scale = torch.narrow(compat_tensor, 0, shape_wieght.numel(), shape_scale.numel()).view(shape_scale)
+            min_val = torch.narrow(compat_tensor, 0,
+                                   shape_wieght.numel() + shape_scale.numel(), shape_min.numel()).view(shape_min)
+
+            return weight, scale, min_val
+
+        return fn
+
+    compat_tensor = torch.concat([quantized_weight, quant_scale, quant_min])
+    if return_param:
+        compat_tensor = nn.Parameter(compat_tensor, requires_grad=False)
+    compat_tensor.deconcat = deconcat_individual_tensors(shape_wieght, shape_scale, shape_min)
+
+    return compat_tensor
+
+
+def _quantize_param(param: nn.Parameter, quant_config: Dict):
+    assert not hasattr(param, 'weight_quantized'), 'Parameter has already been quantized.'
+    quantizer = Quantizer(quant_config)
+    dequantizer = DeQuantizer(quant_config, param.dtype)
+
+    quantized_weight, quant_scale, quant_min = quantizer.quantize(param.data)
+
+    quantized_weight = quantized_weight.view(param.dtype)
+    quant_scale = quant_scale.view(param.dtype)
+    quant_min = quant_min.view(param.dtype)
+
+    quantized_compat_tensor = concat_to_compat_param(quantized_weight, quant_scale, quant_min)
+    param.data = quantized_compat_tensor
+    param.deconcat = quantized_compat_tensor.deconcat
+
+    param.quantizer = quantizer
+    param.dequantizer = dequantizer
+    setattr(param, 'weight_quantized', True)
+
+
+def wrap_quantized_functional(f):
+
+    @functools.wraps(f)
+    def wrapper(input: Tensor, weight: nn.Parameter, *args, **kwargs) -> Tensor:
+        if hasattr(weight, 'weight_quantized') and getattr(weight, 'weight_quantized'):
+            quantized_weight, quant_scale, quant_min = weight.deconcat(weight)
+            temp_dequantized_weight = weight.dequantizer.dequantize(quantized_weight.view(torch.uint8), quant_scale,
+                                                                    quant_min)
+            return f(input, temp_dequantized_weight, *args, **kwargs)
+        else:
+            return f(input, weight, *args, **kwargs)
+
+    return wrapper
+
+
+def wrap_load_from_state_dict(f):
+
+    @functools.wraps(f)
+    def wrapper(model, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
+        replaced_old_value = None
+        key = None
+        # We may have nested wrappers if we launch multiple initialization context.
+        # Use state_dict_quantized flag to quantize state_dict only once
+        if hasattr(model.weight, 'weight_quantized') and getattr(
+                model.weight, 'weight_quantized') and not hasattr(model.weight, 'state_dict_quantized'):
+            setattr(model.weight, 'state_dict_quantized', True)
+            key = prefix + 'weight'
+            if key in state_dict:
+                quantized_weight, quant_scale, quant_min = model.weight.quantizer.quantize(state_dict[key])
+                quantized_weight = quantized_weight.view(model.weight.dtype)
+                quant_scale = quant_scale.view(model.weight.dtype)
+                quant_min = quant_min.view(model.weight.dtype)
+
+                replaced_old_value = state_dict[key]
+
+                state_dict[key] = concat_to_compat_param(quantized_weight, quant_scale, quant_min)
+
+        f(model, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs)
+
+        if replaced_old_value is not None:
+            state_dict[key] = replaced_old_value
+            delattr(model.weight, 'state_dict_quantized')
+
+    return wrapper
+
+
+WEIGHT_QUANTIZATION_LAYERS = (
+    nn.Linear,
+    nn.Embedding,
+)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+from .config_v2 import RaggedInferenceEngineConfig, DeepSpeedTPConfig
+from .engine_v2 import InferenceEngineV2
+from .engine_factory import build_hf_engine, build_engine_from_ds_checkpoint

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/allocator.py

@@ -0,0 +1,42 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from functools import reduce
+from typing import Iterable
+from collections import defaultdict
+import torch
+
+from deepspeed.accelerator import get_accelerator
+
+
+class Allocator:
+    cache = defaultdict(dict)
+
+    def empty_from(tensor: torch.Tensor, shape: Iterable[int]) -> torch.Tensor:
+        try:
+            return Allocator.cache[tensor][shape]
+        except KeyError:
+            shape_size = reduce(lambda x, y: x * y, shape)
+            if shape_size == 0:
+                raise ValueError("Cannot create empty tensor with size 0")
+            Allocator.cache[tensor][shape] = tensor.flatten()[:shape_size].view(shape)
+            return Allocator.cache[tensor][shape]
+
+
+empty_from = Allocator.empty_from
+
+
+def on_device(method) -> torch.Tensor:
+    """
+    Wraps a method to ensure the returned tensor is on the current device.
+    """
+
+    def wrapped(self, *args, **kwargs):
+        tensor = method(self, *args, **kwargs)
+        if isinstance(tensor, torch.Tensor):
+            return tensor.to(get_accelerator().current_device())
+        return tensor
+
+    return wrapped

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/engine_factory.py

@@ -0,0 +1,129 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import json
+import logging
+import os
+import pickle
+from packaging import version
+
+from .engine_v2 import InferenceEngineV2
+from .config_v2 import RaggedInferenceEngineConfig
+from .checkpoint import HuggingFaceCheckpointEngine
+from .logging import inference_logger
+from .model_implementations import (
+    OPTPolicy,
+    Llama2Policy,
+    MistralPolicy,
+    MixtralPolicy,
+    FalconPolicy,
+    PhiPolicy,
+    QwenPolicy,
+    Qwen2Policy,
+)
+from .model_implementations.inference_policy_base import POLICIES, InferenceV2Policy
+from .model_implementations.flat_model_helpers import make_metadata_filename, ModelMetadata
+
+
+def build_engine_from_ds_checkpoint(path: str,
+                                    engine_config: RaggedInferenceEngineConfig,
+                                    debug_level: int = logging.INFO) -> InferenceEngineV2:
+    """
+    Creates an engine from a checkpoint saved by ``InferenceEngineV2``.
+
+    Arguments:
+        path: Path to the checkpoint. This does not need to point to any files in particular,
+            just the directory containing the checkpoint.
+        engine_config: Engine configuration. See ``RaggedInferenceEngineConfig`` for details.
+        debug_level: Logging level to use. Unless you are actively seeing issues, the recommended
+            value is ``logging.INFO``.
+
+    Returns:
+        Fully initialized inference engine ready to serve queries.
+    """
+
+    inference_logger(level=debug_level)
+    # Load metadata, for grabbing the policy name we'll have all ranks just check for
+    # rank 0.
+    metadata_filename = make_metadata_filename(path, 0, engine_config.tensor_parallel.tp_size)
+    metadata = json.load(open(metadata_filename, "r"))
+    metadata = ModelMetadata.parse_raw(metadata)
+
+    # Get the policy
+    try:
+        policy_cls: InferenceV2Policy = POLICIES[metadata.policy]
+    except KeyError:
+        raise ValueError(f"Unknown policy {metadata.policy} for model {path}")
+
+    # Load the model config
+    model_config = pickle.load(open(os.path.join(path, "ds_model_config.pkl"), "rb"))
+    policy = policy_cls(model_config, inf_checkpoint_path=path)
+
+    return InferenceEngineV2(policy, engine_config)
+
+
+def build_hf_engine(path: str,
+                    engine_config: RaggedInferenceEngineConfig,
+                    debug_level: int = logging.INFO) -> InferenceEngineV2:
+    """
+    Build an InferenceV2 engine for HuggingFace models. This can accept both a HuggingFace
+    model name or a path to an Inference-V2 checkpoint.
+
+    Arguments:
+        path: Path to the checkpoint. This does not need to point to any files in particular,
+            just the directory containing the checkpoint.
+        engine_config: Engine configuration. See ``RaggedInferenceEngineConfig`` for details.
+        debug_level: Logging level to use. Unless you are actively seeing issues, the recommended
+            value is ``logging.INFO``.
+
+    Returns:
+        Fully initialized inference engine ready to serve queries.
+    """
+
+    if os.path.exists(os.path.join(path, "ds_model_config.pkl")):
+        return build_engine_from_ds_checkpoint(path, engine_config, debug_level=debug_level)
+    else:
+        # Set up logging
+        inference_logger(level=debug_level)
+        # get HF checkpoint engine
+        checkpoint_engine = HuggingFaceCheckpointEngine(path)
+
+        # get model config from HF AutoConfig
+        model_config = checkpoint_engine.model_config
+
+        # get the policy
+        # TODO: generalize this to other models
+        if model_config.model_type == "opt":
+            if not model_config.do_layer_norm_before:
+                raise ValueError(
+                    "Detected OPT-350m model. This model is not currently supported. If this is not the 350m model, please open an issue: https://github.com/microsoft/DeepSpeed-MII/issues"
+                )
+            policy = OPTPolicy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "llama":
+            policy = Llama2Policy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "mistral":
+            # Ensure we're using the correct version of transformers for mistral
+            import transformers
+            assert version.parse(transformers.__version__) >= version.parse("4.34.0"), \
+                f"Mistral requires transformers >= 4.34.0, you have version {transformers.__version__}"
+            policy = MistralPolicy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "mixtral":
+            # Ensure we're using the correct version of transformers for mistral
+            import transformers
+            assert version.parse(transformers.__version__) >= version.parse("4.36.1"), \
+                f"Mistral requires transformers >= 4.36.1, you have version {transformers.__version__}"
+            policy = MixtralPolicy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "falcon":
+            policy = FalconPolicy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "phi":
+            policy = PhiPolicy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "qwen":
+            policy = QwenPolicy(model_config, checkpoint_engine=checkpoint_engine)
+        elif model_config.model_type == "qwen2":
+            policy = Qwen2Policy(model_config, checkpoint_engine=checkpoint_engine)
+        else:
+            raise ValueError(f"Unsupported model type {model_config.model_type}")
+
+        return InferenceEngineV2(policy, engine_config)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/inference_parameter.py

@@ -0,0 +1,89 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Dict
+
+import torch
+
+CORE_PARAM = "_ds_core_param_key"
+
+STR_TO_DTYPE = {
+    "torch.float32": torch.float32,
+    "torch.float64": torch.float64,
+    "torch.float16": torch.float16,
+    "torch.bfloat16": torch.bfloat16,
+    "torch.int64": torch.int64,
+    "torch.int32": torch.int32,
+    "torch.int16": torch.int16,
+    "torch.int8": torch.int8,
+    "torch.uint8": torch.uint8,
+    "torch.bool": torch.bool,
+}
+
+
+class InferenceParameter(torch.Tensor):
+    """
+    An extension of the torch.Tensor class to support our inference focused features. One important
+    thing to note here is that an InferenceParam can be used a torch.Tensor, but outputs of
+    torch.Tensor operations will not be InferenceParams.
+    """
+
+    @staticmethod
+    def __new__(cls, tensor, *args, **kwargs):
+        new_tensor = super().__new__(cls, tensor, *args, **kwargs)
+        if hasattr(tensor, "_aux_attrs"):
+            setattr(new_tensor, "_aux_attrs", tensor.aux_attrs)
+        return new_tensor
+
+    def to(self, *args, **kwargs):
+        new_tensor = super().to(*args, **kwargs)
+        if hasattr(self, "_aux_attrs"):
+            setattr(new_tensor, "_aux_attrs", self.aux_attrs)
+        try:
+            _ = torch.device(args[0])
+            for name, attr in new_tensor.aux_attrs.items():
+                new_attr = attr.to(*args, **kwargs)
+                setattr(new_tensor, name, new_attr)
+                new_tensor.aux_attrs[name] = new_attr
+        except:
+            pass
+
+        return new_tensor
+
+    @classmethod
+    def initialize(cls, core_param: torch.Tensor, **kwargs) -> 'InferenceParameter':
+        """
+        Create the inference parameter.
+        """
+        param = InferenceParameter(core_param)
+        setattr(param, "_aux_attrs", kwargs)
+
+        for attr_name, attr in kwargs.items():
+            if hasattr(param, attr_name):
+                raise ValueError(f"Attribute {attr_name} already exists on param.")
+
+            if not isinstance(attr, torch.Tensor):
+                raise ValueError(f"Attribute {attr_name} must be a tensor.")
+
+            setattr(param, attr_name, attr)
+
+        return param
+
+    @classmethod
+    def initialize_raw(self, **kwargs) -> 'InferenceParameter':
+        """
+        All kwargs must be torch.Tensors and must include the core parameter.
+        """
+        if CORE_PARAM not in kwargs:
+            raise ValueError(f"Must provide core parameter, with key {CORE_PARAM}.")
+
+        return InferenceParameter.initialize(kwargs[CORE_PARAM], **kwargs)
+
+    @property
+    def aux_attrs(self) -> Dict[str, torch.Tensor]:
+        """
+        Dictionary of auxiliary attributes.
+        """
+        return self._aux_attrs

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/inference_utils.py

@@ -0,0 +1,105 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Dict
+
+import torch
+
+from enum import Enum, IntEnum
+
+
+class NormTypeEnum(Enum):
+    LayerNorm: str = "layer_norm"
+    RMSNorm: str = "rms_norm"
+
+
+class DtypeEnum(Enum):
+    # The torch dtype must always be the first value (so we return torch.dtype)
+    fp16 = torch.float16, "torch.float16", "fp16", "float16", "half"
+    fp32 = torch.float32, "torch.float32", "fp32", "float32", "float"
+    bf16 = torch.bfloat16, "torch.bfloat16", "bf16", "bfloat16", "bfloat"
+    int8 = torch.int8, "torch.int8", "int8"
+
+    # Copied from https://stackoverflow.com/a/43210118
+    # Allows us to use multiple values for each Enum index and returns first
+    # listed value when Enum is called
+    def __new__(cls, *values):
+        obj = object.__new__(cls)
+        # first value is canonical value
+        obj._value_ = values[0]
+        for other_value in values[1:]:
+            cls._value2member_map_[other_value] = obj
+        obj._all_values = values
+        return obj
+
+    def __repr__(self):
+        return "<%s.%s: %s>" % (
+            self.__class__.__name__,
+            self._name_,
+            ", ".join([repr(v) for v in self._all_values]),
+        )
+
+
+ELEM_SIZES: Dict[torch.dtype, int] = {
+    torch.float16: 2,
+    torch.bfloat16: 2,
+    torch.float32: 4,
+    torch.float64: 8,
+    torch.int8: 1,
+    torch.uint8: 1,
+    torch.int16: 2,
+    torch.int32: 4,
+    torch.int64: 8,
+    torch.bool: 1,
+}
+
+
+class ActivationType(IntEnum):
+    """
+    Types of activations supported by DS-Inference
+    """
+
+    GELU = 0
+
+    RELU = 1
+
+    SILU = 2
+
+    GEGLU = 3
+
+    ReGLU = 4
+
+    SiGLU = 5
+
+    IDENTITY = 6
+
+    InvalidType = -1
+
+
+def is_gated(act_fn: ActivationType) -> bool:
+    """
+    Return True if the given activation function is gated.
+    """
+    if not isinstance(act_fn, ActivationType):
+        act_fn = ActivationType(act_fn)
+
+    return act_fn in [ActivationType.GEGLU, ActivationType.ReGLU, ActivationType.SiGLU]
+
+
+def elem_size(dtype: torch.dtype) -> int:
+    """
+    Return size in bytes of the given dtype.
+    """
+    try:
+        return ELEM_SIZES[dtype]
+    except KeyError:
+        raise ValueError("Unknown dtype size for {}".format(dtype))
+
+
+def ceil_div(a: int, b: int) -> int:
+    """
+    Return ceil(a / b).
+    """
+    return -(-a // b)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .attn_output_parameters import *
+from .embedding_parameters import *
+from .mlp_parameters import *
+from .moe_parameters import *
+from .norm_parameters import *
+from .qkv_parameters import *
+from .unembed_parameters import *
+from .invfreq_parameters import *

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/attn_output_parameters.py

@@ -0,0 +1,29 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+Common Attention Output Parameter Patterns
+"""
+
+
+class AttentionOutputParameter(ParameterBase):
+    """
+    Attention output parameter container.
+
+    Note: The differentiation for something like GQA for this matrix is primarily
+    encompassed in the sharding logic, which is currently expected to be performed by
+    the model implementation.
+    """
+
+    params: torch.Tensor
+    """
+    Unsharded attention output parameter of shape [model_dim, model_dim]
+    """
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_attn_out_param(self.params)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/embedding_parameters.py

@@ -0,0 +1,26 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+Embedding containers.
+"""
+
+
+class EmbeddingParameter(ParameterBase):
+    """
+    Embedding container. This should be safe to use for all types of embeddings (i.e. word, position,
+    and token type).
+    """
+
+    params: torch.Tensor
+    """
+    Vocabulary parameter of shape [vocab_size, model_dim].
+    """
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_embedding_param(self.params)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/invfreq_parameters.py

@@ -0,0 +1,19 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+Common InvFreq Parameter Patterns
+"""
+
+
+class InvFreqParameter(ParameterBase):
+
+    params: torch.Tensor
+
+    def finalize(self) -> torch.Tensor:
+        return self.params.to(self.inference_model.activation_dtype.value)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/mlp_parameters.py

@@ -0,0 +1,81 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+MLP Parameter Containers
+"""
+
+
+class MLP1Parameter(ParameterBase):
+    """
+    First MLP projection weight container. This performs a straight pass-through to the
+    model implementation for transformation.
+    """
+    params: torch.Tensor
+
+    def finalize(self) -> torch.Tensor:
+        # NOTE(cmikeh2): If we are gated but not in the format specified below, we should trigger a permutation here.
+        # I am not currently aware of any models that use this format (or how we should even detect it; probably should
+        # just be a different param entirely, but until then we'll just assume the format is correct).
+        return self.inference_model.transform_mlp_1_param(self.params)
+
+
+class GatedMLPParameter(ParameterBase):
+    """
+    Gated MLP projection container.
+    """
+
+    gate_params: torch.Tensor
+    """
+    Weight parameter for the gating matrix.
+    """
+
+    up_params: torch.Tensor
+    """
+    For lack of a better name, the non-gating weight parameters.
+    """
+
+    def finalize(self) -> torch.Tensor:
+        """
+        Our gated format (this is different from InferenceV1!) is to have the gate and activated neurons
+        interleaved. So if we have 4 output neurons (two effective neurons) with 4 input neurons, the finalized
+        parameter will look like:
+        [g0_0, g0_1, g0_2, g0_3]
+        [a0_0, a0_1, a0_2, a0_3]
+        [g1_0, g1_1, g1_2, g1_3]
+        [a1_0, a1_1, a1_2, a1_3]
+
+        As a reference, in inference v1, the format is:
+        [g0_0, g0_1, g0_2, g0_3]
+        [g1_0, g1_1, g1_2, g1_3]
+        [a0_0, a0_1, a0_2, a0_3]
+        [a1_0, a1_1, a1_2, a1_3]
+        """
+        assert self.gate_params.shape[0] == self.up_params.shape[
+            0], "Gated MLP parameters must have the same number of neurons."
+        total_neurons = self.gate_params.shape[0] + self.up_params.shape[0]
+
+        # flip the order if even with the correct tokenizer we get wrong output
+        #fused_param = torch.cat([self.up_params, self.gate_params], dim=-1).reshape(total_neurons, -1)
+        fused_param = torch.cat([self.gate_params, self.up_params], dim=-1).reshape(total_neurons, -1)
+        return self.inference_model.transform_mlp_1_param(fused_param)
+
+
+class MLP2Parameter(ParameterBase):
+    """
+    Second MLP projection weight container. This performs a straight pass-through to the
+    model implementation for transformation.
+    """
+
+    params: torch.Tensor
+    """
+    Full weight parameter.
+    """
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_mlp_2_param(self.params)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/moe_parameters.py

@@ -0,0 +1,78 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase, ParamList
+"""
+Moe Parameters
+
+These parameters are compatible with any model inheriting from ``DSMoETransformerModelBase``.
+"""
+
+
+class MoEGatingWeightParameter(ParameterBase):
+    """
+    Gating weight matrix.
+    """
+
+    params: torch.Tensor
+    """
+    Projection matrix from the input activations to the gate logits.
+    """
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_moe_gate_param(self.params)
+
+
+class UnfusedMoEMLP1Parameter(ParameterBase):
+    """
+    This container should be used when the experts are held in separate parameters
+    and need to be joined into a single group.
+    """
+
+    experts: ParamList("n_experts")  # noqa: F821
+
+    def finalize(self) -> torch.Tensor:
+        stacked_experts = torch.stack([p for p in self.experts], dim=0)
+        return self.inference_model.transform_moe_mlp_1_param(stacked_experts)
+
+
+class UnfusedMoEMLP2Parameter(ParameterBase):
+    """
+    This container should be used when the experts are held in separate parameters
+    and need to be joined into a single group.
+    """
+
+    experts: ParamList("n_experts")  # noqa: F821
+
+    def finalize(self) -> torch.Tensor:
+        stacked_experts = torch.stack([p for p in self.experts], dim=0)
+        return self.inference_model.transform_moe_mlp_2_param(stacked_experts)
+
+
+class UnfusedMoEGatedMLPParameter(ParameterBase):
+    """
+    MoE Parameter for a gated activation function in which the gating matrix is not
+    fused in the same parameter as the non-gating matrix.
+
+    This is a stacked version of the ``GatedMLPParameter``. Please see that class for more
+    documentation on the layout of the parameters.
+    """
+
+    gating_experts: ParamList("n_experts")  # noqa: F821
+
+    up_experts: ParamList("n_experts")  # noqa: F821
+
+    def finalize(self) -> torch.Tensor:
+        transposed_experts = []
+        for gate, up in zip(self.gating_experts, self.up_experts):
+            assert gate.shape[0] == up.shape[0], "Gated MLP parameters must have the same number of neurons."
+            total_neurons = gate.shape[0] + up.shape[0]
+            fused_expert = torch.cat([gate, up], dim=-1).reshape(total_neurons, -1)
+            transposed_experts.append(fused_expert)
+
+        stacked_experts = torch.stack(transposed_experts, dim=0)
+        return self.inference_model.transform_moe_mlp_1_param(stacked_experts)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/norm_parameters.py

@@ -0,0 +1,22 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+Common Attention Output Parameter Patterns
+"""
+
+
+class NormParameter(ParameterBase):
+    """
+    Simple normalization container.
+    """
+
+    params: torch.Tensor
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_norm_param(self.params)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/qkv_parameters.py

@@ -0,0 +1,115 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+Common QKV Parameter Patterns
+"""
+
+
+class FusedQKVParameter(ParameterBase):
+    """
+    Traditional fused QKV parameters for QKV projection. This is functionally
+    a direct copy.
+
+    src_qkv_w shape: [3 * out_features, in_features]
+    qkv_w shape: [3 * out_features, in_features]
+    """
+
+    params: torch.Tensor
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_qkv_param(self.params)
+
+
+class UnfusedQKVParameter(ParameterBase):
+    """
+    QKV parameter container for unfused QKV projection.
+
+    src_param shapes: 3 x [out_features, in_features]
+    dst_param shape: [3 x out_features, in_features]
+    """
+
+    q_params: torch.Tensor
+
+    k_params: torch.Tensor
+
+    v_params: torch.Tensor
+
+    def finalize(self):
+        fused_param = torch.cat([self.q_params, self.k_params, self.v_params], dim=0)
+        return self.inference_model.transform_qkv_param(fused_param)
+
+
+def megatron_qkv_reshape(param: torch.Tensor, head_size: int, n_heads: int) -> torch.Tensor:
+    assert param.shape[0] == 3 * n_heads * head_size
+
+    all_heads = torch.chunk(param, chunks=3 * n_heads, dim=0)
+    q_heads = all_heads[::3]
+    k_heads = all_heads[1::3]
+    v_heads = all_heads[2::3]
+    return torch.cat([q_heads, k_heads, v_heads], dim=0)
+
+
+class MegatronQKVParameter(ParameterBase):
+    """
+    QKV parameter container for Megatron-style QKV projection. Megatron stores the parameter
+    as [n_heads, 3, head_size, in_features] whereas our inference system is built around
+    [3, n_heads, head_size, in_features]. This container handles the conversion.
+
+    Note: this container expects the model implementation to implement properties for
+    `head_size` and `n_heads`.
+
+    src_qkv_w shape: [3 * out_features, in_features]
+    qkv_w shape: [3 * out_features, in_features]
+    """
+
+    params: torch.Tensor
+
+    def finalize(self) -> torch.Tensor:
+        head_size = self.inference_model.head_size
+        n_heads = self.inference_model.n_heads
+
+        transposed_param = megatron_qkv_reshape(self.params, head_size, n_heads)
+        return self.inference_model.transform_qkv_param(transposed_param)
+
+
+def transform_gqa_megatron(src_param: torch.Tensor, head_size: int, n_q_heads: int, n_kv_heads: int) -> torch.Tensor:
+    assert src_param.shape[0] == (2 * n_kv_heads + n_q_heads) * head_size
+
+    head_ratio = n_q_heads // n_kv_heads
+
+    # Reshape to get the groups as the leading dimension
+    groups_leading_view = src_param.reshape(n_kv_heads, 2 + head_ratio, head_size, -1)
+    q_heads = groups_leading_view[:, :head_ratio, :, :].reshape(-1, groups_leading_view.shape[-1])
+    k_heads = groups_leading_view[:, head_ratio, :, :].reshape(-1, groups_leading_view.shape[-1])
+    v_heads = groups_leading_view[:, head_ratio + 1, :, :].reshape(-1, groups_leading_view.shape[-1])
+    # Squeeze will remove extra dimension for bias
+    return torch.cat([q_heads, k_heads, v_heads], dim=0).squeeze()
+
+
+class GQAMegatronQKVParameter(ParameterBase):
+    """
+    QKV parameter for Megatron-style QKV projection with GQA-style QKV projection. In this
+    storage format each of the groups is stored consecutively, so there will be multiple q_heads,
+    then one k head, and one v head.
+
+    Note: this container expects the model implementation to implement properties for
+    `head_size`, `n_q_heads`, and `n_kv_heads`.
+
+    src_qkv_w shape: [(2 * n_kv_heads + n_q_heads) * head_size, in_features]
+    qkv_w shape: [(2 * n_kv_heads + n_q_heads) * head_size, in_features]
+    """
+
+    params: torch.Tensor
+
+    def finalize(self) -> torch.Tensor:
+        head_size = self.inference_model.head_size
+        n_q_heads = self.inference_model.n_heads_q
+        n_kv_heads = self.inference_model.n_heads_kv
+        transposed_param = transform_gqa_megatron(self.params, head_size, n_q_heads, n_kv_heads)
+        return self.inference_model.transform_qkv_param(transposed_param)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/common_parameters/unembed_parameters.py

@@ -0,0 +1,26 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ...model_implementations.parameter_base import ParameterBase
+"""
+Unembedding containers.
+"""
+
+
+class UnembedParameter(ParameterBase):
+    """
+    Unembedding parameter. This will likely be mapped to the same original weight in the model as the
+    embedding, but we have a different preferred sharding approach.
+    """
+
+    params: torch.Tensor
+    """
+    Unembedding parameter of shape [vocab_size, model_dim].
+    """
+
+    def finalize(self) -> torch.Tensor:
+        return self.inference_model.transform_unembed_param(self.params)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/flat_model_helpers.py

@@ -0,0 +1,282 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Dict, Iterable, Tuple, Optional
+from os import path
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from deepspeed.ops.op_builder import RaggedUtilsBuilder
+from deepspeed.runtime.config_utils import DeepSpeedConfigModel
+from .layer_container_base import LayerContainer
+from ..inference_parameter import InferenceParameter, STR_TO_DTYPE
+from ..inference_utils import elem_size
+
+
+def pad_to_aligned_offset(offset: int, alignment: int = 256) -> int:
+    """
+    Pad the provided offset to a well-aligned value.
+    """
+    return ((offset + alignment - 1) // alignment) * alignment
+
+
+class TensorMetadata(DeepSpeedConfigModel):
+    """
+    A class to represent a tensor specification.
+    """
+    dtype: Optional[str]
+    shape: Optional[Tuple[int, ...]]
+    strides: Optional[Tuple[int, ...]]
+    offset: int
+
+
+class ParameterMetadata(DeepSpeedConfigModel):
+    """
+    A class to represent a parameter specification.
+    """
+    core_param: TensorMetadata = None
+    aux_params: Dict[str, TensorMetadata] = {}
+
+
+class LayerMetadata(DeepSpeedConfigModel):
+    """
+    A class to represent a layer specification.
+    """
+    params: Dict[str, ParameterMetadata] = {}
+
+
+class ModelMetadata(DeepSpeedConfigModel):
+    """
+    A class to represent a model specification.
+    """
+    policy: str = ""
+    layers: Dict[str, LayerMetadata] = {}
+
+
+def make_param_filename(base: str, rank: int, n_ranks: int) -> str:
+    """
+    Make a filename for a parameter file.
+
+    Arguments:
+        rank: Rank of the file.
+        n_ranks: Total number of ranks.
+
+    Returns:
+        str: Filename.
+    """
+    return path.join(base, f"params_rank_{rank}_of_{n_ranks}.pt")
+
+
+def make_metadata_filename(base: str, rank: int, n_ranks: int) -> str:
+    """
+    Make a filename for a metadata file.
+
+    Arguments:
+        rank: Rank of the file.
+        n_ranks: Total number of ranks.
+
+    Returns:
+        str: Filename.
+    """
+    return path.join(base, f"metadata_rank_{rank}_of_{n_ranks}.json")
+
+
+def make_model_config_filename(base: str) -> str:
+    """
+    Make a filename for a model config file.
+
+    Arguments:
+        base: Base directory.
+
+    Returns:
+        str: Filename.
+    """
+    return path.join(base, "ds_model_config.json")
+
+
+def flatten_inference_model(
+    transformer_containers: Iterable[LayerContainer],
+    non_transformer_container: LayerContainer,
+    policy_name: str,
+) -> Tuple[torch.Tensor, ModelMetadata]:
+    """
+    Flatten the underlying parameters into
+
+    Arguments:
+        transformer_containers: Iterable of layer containers corresponding to the transformer
+            parameters.
+        non_transformer_container: Layer container corresponding to the non-transformer parameters.
+        policy_name: The name of the policy class (typically accessed with `type(policy).__name__`).
+
+    Returns:
+        Iterable[Any]: Flattened list of parameters.
+    """
+    alloc_fn = RaggedUtilsBuilder().load().allocate_view_on
+
+    total_size = 0
+    metadata = ModelMetadata(policy=policy_name)
+
+    def process_layer(layer_container: LayerContainer, l_name: str, cur_offset: int) -> int:
+        """
+        Iterate over the parameters of a single container and collect metadata for the final
+        flattened buffer.
+
+        Arguments:
+            layer_container: The layer container to process.
+            l_name: The name of the layer container to key the metadata.
+            cur_offset: The current offset into the flattened buffer.
+
+        Captured Variables:
+            metadata: The metadata object to populate.
+
+        Returns:
+            int: The updated offset into the flattened buffer.
+        """
+        try:
+            _ = layer_container.is_populated
+        except ValueError as e:
+            raise ValueError(f"Layer container {l_name} is not populated.") from e
+
+        layer_metadata = LayerMetadata()
+
+        for p_name in layer_container.annotation_attrs:
+            param = getattr(layer_container, p_name)
+            param_metadata = ParameterMetadata()
+
+            if param is None:
+                param_metadata.core_param = TensorMetadata(offset=-1)
+                layer_metadata.params[p_name] = param_metadata
+                continue
+
+            param_metadata.core_param = TensorMetadata(dtype=str(param.dtype),
+                                                       shape=param.shape,
+                                                       strides=param.stride(),
+                                                       offset=cur_offset)
+
+            cur_offset += pad_to_aligned_offset(elem_size(param.dtype) * param.numel())
+
+            for t_name, tensor in param.aux_attrs.items():
+                param_metadata.aux_params[t_name] = TensorMetadata(dtype=str(tensor.dtype),
+                                                                   shape=tensor.shape,
+                                                                   strides=tensor.stride(),
+                                                                   offset=cur_offset)
+
+                cur_offset += pad_to_aligned_offset(elem_size(tensor.dtype) * tensor.numel())
+
+            layer_metadata.params[p_name] = param_metadata
+
+        metadata.layers[l_name] = layer_metadata
+        return cur_offset
+
+    for i, layer in enumerate(transformer_containers):
+        l_name = f"transformer_layer_{i}"
+        total_size = process_layer(layer, l_name, total_size)
+
+    l_name = "non_transformer"
+    total_size = process_layer(non_transformer_container, l_name, total_size)
+
+    buffer = torch.empty(total_size, dtype=torch.uint8, device=get_accelerator().current_device())
+
+    def copy_layer(layer_container: LayerContainer, l_name: str) -> None:
+        """
+        Local method for copying from the layer container to the flattened buffer.
+
+        Arguments:
+            layer_container: The layer container to copy from.
+            l_name: The name of the layer container to key the metadata.
+
+        Captured Variables:
+            buffer: The flattened buffer to copy into.
+            metadata: The metadata object to populate.
+        """
+        l_metadata = metadata.layers[l_name]
+        for p_name in layer_container.annotation_attrs:
+            p_metadata = l_metadata.params[p_name]
+            param = getattr(layer_container, p_name)
+
+            if param is None:
+                continue
+
+            core_param = alloc_fn(param, buffer, p_metadata.core_param.offset)
+            core_param.copy_(param)
+
+            aux_params = {}
+
+            for t_name, tensor in param.aux_attrs.items():
+                t_view = alloc_fn(tensor, buffer, p_metadata.aux_params[t_name].offset)
+                aux_params[t_name] = t_view
+                t_view.copy_(tensor)
+
+            setattr(layer_container, p_name, InferenceParameter.initialize(core_param, **aux_params))
+
+    for i, layer in enumerate(transformer_containers):
+        l_name = f"transformer_layer_{i}"
+        copy_layer(layer, l_name)
+
+    l_name = "non_transformer"
+    copy_layer(non_transformer_container, l_name)
+
+    return buffer, metadata
+
+
+def restore_inference_model(buffer: torch.Tensor, metadata: ModelMetadata,
+                            transformer_containers: Iterable[LayerContainer],
+                            non_transformer_container: LayerContainer) -> None:
+    """
+    Restore the model from the buffer and metadata.
+
+    Arguments:
+        buffer: Buffer containing the model parameters.
+        metadata: Metadata for the model.
+        transformer_containers: Iterable of transformer layer containers.
+        non_transformer_container: Non-transformer layer container.
+    """
+    alloc_fn = RaggedUtilsBuilder().load().allocate_view_like
+
+    def restore_layer(layer_container: LayerContainer, l_name: str) -> None:
+        """
+        Local method for restoring a layer container from a flattened buffer. This
+        only constructs views for the parameters onto the buffer. No data movement
+        is performed.
+
+        Arguments:
+            layer_container: The layer container to restore.
+            l_name: The name of the layer container to key the metadata.
+
+        Captured Variables:
+            buffer: The flattened buffer to reconstruct views on top of.
+            metadata: The metadata object describing the each parameter in the model.
+        """
+        l_metadata = metadata.layers[l_name]
+
+        for p_name in layer_container.annotation_attrs:
+            p_metadata = l_metadata.params[p_name]
+
+            if p_metadata.core_param.offset == -1:
+                layer_container.direct_injection(p_name, None)
+                continue
+
+            dummy_tensor = torch.empty([], dtype=STR_TO_DTYPE[p_metadata.core_param.dtype])
+            core_param = alloc_fn(p_metadata.core_param.shape, p_metadata.core_param.strides, dummy_tensor, buffer,
+                                  p_metadata.core_param.offset)
+
+            aux_params = {}
+
+            for t_name, t_metadata in p_metadata.aux_params.items():
+                dummy_tensor = torch.empty([], dtype=STR_TO_DTYPE[t_metadata.dtype])
+                t_view = alloc_fn(t_metadata.shape, t_metadata.strides, dummy_tensor, buffer, t_metadata.offset)
+
+                aux_params[t_name] = t_view
+
+            restored_param = InferenceParameter.initialize(core_param, **aux_params)
+            layer_container.direct_injection(p_name, restored_param)
+
+    for i, layer in enumerate(transformer_containers):
+        l_name = f"transformer_layer_{i}"
+        restore_layer(layer, l_name)
+
+    l_name = "non_transformer"
+    restore_layer(non_transformer_container, l_name)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/inference_policy_base.py

@@ -0,0 +1,220 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import json
+from abc import ABC, ABCMeta, abstractmethod
+from typing import Any, Iterable, List, Optional, Union
+
+import torch
+
+from ..config_v2 import RaggedInferenceEngineConfig
+from ..checkpoint import CheckpointEngineBase
+from ..logging import inference_logger
+from .layer_container_base import LayerContainer
+from .inference_model_base import DSInferenceModelBase
+from .flat_model_helpers import (
+    flatten_inference_model,
+    make_param_filename,
+    make_metadata_filename,
+    ModelMetadata,
+    restore_inference_model,
+)
+
+POLICIES = {}
+
+
+class ContainerMap:
+
+    def __init__(self) -> None:
+        self._prefix_map = {}
+        self._transformer_params = None
+        self._non_transformer_params = None
+
+    @property
+    def transformer_params(self) -> Iterable[LayerContainer]:
+        return self._transformer_params
+
+    @property
+    def non_transformer_params(self) -> LayerContainer:
+        return self._non_transformer_params
+
+    def set_transformer_params(self, prefixes: Union[str, Iterable[str]], containers: List[LayerContainer]) -> None:
+        if not isinstance(containers, list):
+            raise ValueError(
+                f"The transformer containers should be a list, of one container per layer, but got {type(containers)} instead."
+            )
+
+        self._transformer_prefixes = prefixes if isinstance(prefixes, list) else [prefixes]
+        self._transformer_params = containers
+
+    def set_non_transformer_params(self, container: LayerContainer) -> None:
+        self._non_transformer_params = container
+
+    def set_unmapped_params(self, prefixes: Union[str, Iterable[str]]) -> None:
+        self._unmapped_prefixes = prefixes
+
+    def map_param(self, name, parameter) -> None:
+        for unmapped_prefix in self._unmapped_prefixes:
+            if name.startswith(unmapped_prefix):
+                inference_logger().debug(f"Ignoring: {name} for {unmapped_prefix}")
+                return
+
+        for transformer_prefix in self._transformer_prefixes:
+            if name.startswith(transformer_prefix):
+                popped_name = name[len(transformer_prefix) + 1:]
+                layer_idx = popped_name.split(".")[0]
+                assert layer_idx.isdigit(
+                ), f"expected name to start w. list index but got {layer_idx} instead, name={name}"
+                layer_idx = int(layer_idx)
+                inference_logger().debug(
+                    f"Setting: {'.'.join(popped_name.split('.')[1:])} for layer-idx={layer_idx} to {parameter.shape}")
+                self._transformer_params[layer_idx].set_dependency(".".join(popped_name.split(".")[1:]), parameter)
+                return
+
+        try:
+            inference_logger().debug(f"Setting: {name} to {parameter.shape}")
+            self._non_transformer_params.set_dependency(name, parameter)
+        except ValueError:
+            # Catch the ValueError here from the non_transformer_params because we are knowingly
+            # calling it with something that may not match. This should allow us to raise a slightly more
+            # informative error message.
+            raise ValueError(f"Cannot find container for {name}, please double check the Containers/ContainerMap")
+
+    def validate(self) -> None:
+        if not self._non_transformer_params.is_initialized:
+            raise RuntimeError("Non-transformer parameters not fully initialized after checkpoint load.")
+
+        for layer_idx, container in enumerate(self._transformer_params):
+            if not container.is_initialized:
+                raise RuntimeError(
+                    f"Transformer container at index {layer_idx} not fully initialized after checkpoint load.")
+
+
+class PolicyMeta(ABCMeta):
+
+    def __new__(cls, name, bases, dct):
+        new_obj = super().__new__(cls, name, bases, dct)
+        if name != "InferenceV2Policy":
+            POLICIES[name] = new_obj
+        return new_obj
+
+
+class InferenceV2Policy(ABC, metaclass=PolicyMeta):
+    """
+    The InferenceV2Policy is the base class for all inference policies. An inference policy
+    is responsible for instantiating the inference model and mapping the parameters from the
+    checkpoint engine to the model itself.
+    """
+
+    def __init__(
+        self,
+        model_config: Any,
+        checkpoint_engine: Optional[CheckpointEngineBase] = None,
+        inf_checkpoint_path: Optional[str] = None,
+    ) -> None:
+        """
+        Create the Policy with sufficient context to build the model. There are two supported
+        model creation mechanisms.
+
+        The first is the generalized ``checkpoint_engine`` which
+        will iterate over the parameters of the model and provide them to the policy. These in
+        turn will be sharded/transformed by the model implementation.
+
+        The second is used to re-create a previously serialized DeepSpeed inference model. These
+        checkpoints should not be used across different model backend configurations.
+
+        TODO(cmikeh2): Enforce this in code
+        """
+        if checkpoint_engine is None and inf_checkpoint_path is None:
+            raise ValueError("Either checkpoint_engine or ds_checkpoint_path must be provided.")
+
+        if checkpoint_engine is not None and inf_checkpoint_path is not None:
+            raise ValueError("Only one of checkpoint_engine or ds_checkpoint_path can be provided.")
+
+        self._checkpoint_engine = checkpoint_engine
+        self._inf_checkpoint_path = inf_checkpoint_path
+        self._model_config = model_config
+
+    def build_model(self, engine_config: RaggedInferenceEngineConfig, mp_group: Any) -> DSInferenceModelBase:
+        """
+        Completely instantiate the inference model. This will both create the ops needed to run the
+        model, as well as load the model parameters via the checkpoint engine. For more context
+        on each of these components please see ``instantiate_model`` and ``populate_model_parameters``.
+
+        Arguments:
+            engine_config: The config that has been used to instantiate the engine. This is used
+                to communicate to the model implementation the limits on batches (sequences/tokens)
+                and bound the size of intermediate buffers.
+            mp_group: Object to enable communication between tensor parallel ranks.
+
+        Returns:
+            DSInferenceModelBase: An implementation of the inference model abstraction that will be
+                run by the engine.
+        """
+        self.model = self.instantiate_model(engine_config, mp_group)
+        self.populate_model_parameters()
+        return self.model
+
+    @abstractmethod
+    def instantiate_model(self, engine_config: RaggedInferenceEngineConfig) -> DSInferenceModelBase:
+        """
+        Instantiate the inference model. Depending on the engine/model config, this could be where
+        different model implementations could be selected.
+
+        Arguments:
+            engine_config: The config that has been used to instantiate the engine. This is used
+                to communicate to the model implementation the limits on batches (sequences/tokens)
+                and bound the size of intermediate buffers.
+
+        Returns:
+            DSInferenceModelBase: An implementation of the inference model abstraction that will be
+                run by the engine.
+        """
+        ...
+
+    @abstractmethod
+    def build_container_map(self) -> ContainerMap:
+        """
+        Build a dictionary representing the structure of the string prefixes leading
+        to the parameters to be mapped to the container.
+
+        Returns:
+            ContainerMap: An instantiated mapping describing how checkpoint prefixes map
+                to ``LayerContainer`` instances.
+        """
+        raise NotImplementedError()
+
+    def populate_model_parameters(self) -> None:
+        """
+        This model will iterate over the parameters (as provided by the checkpoint engine) and
+        use the container map built by ``build_container_map`` to populate the model
+        """
+
+        container_map = self.build_container_map()
+
+        if self._checkpoint_engine is not None:
+            for name, parameter in self._checkpoint_engine.parameters():
+                container_map.map_param(name, parameter)
+
+            buffer, metadata = flatten_inference_model(container_map.transformer_params,
+                                                       container_map.non_transformer_params, self.__class__.__name__)
+        else:
+
+            buffer_path = make_param_filename(self._inf_checkpoint_path, self.model.tp_rank, self.model.tp_size)
+            metadata_path = make_metadata_filename(self._inf_checkpoint_path, self.model.tp_rank, self.model.tp_size)
+
+            buffer = torch.load(buffer_path)
+            metadata = json.load(open(metadata_path, "r"))
+            metadata = ModelMetadata.parse_raw(metadata)
+
+            restore_inference_model(buffer, metadata, container_map.transformer_params,
+                                    container_map.non_transformer_params)
+
+        container_map.validate()
+
+        self.model.set_parameters(transformer=container_map.transformer_params,
+                                  non_transformer=container_map.non_transformer_params,
+                                  flattened_param_buffer=buffer,
+                                  flattened_param_metadata=metadata)

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/inference_transformer_base.py

@@ -0,0 +1,617 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from abc import abstractmethod
+from typing import Optional
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from ..config_v2 import RaggedInferenceEngineConfig
+from ..inference_utils import ActivationType, ceil_div, is_gated
+from ..model_implementations import *
+from ..model_implementations.sharding import *
+from ..modules.configs import (
+    DSEmbeddingsConfig,
+    DSLinearConfig,
+    DSMoEConfig,
+    DSNormConfig,
+    DSSelfAttentionConfig,
+    DSUnembedConfig,
+    NormTypeEnum,
+    PositionalEmbeddingType,
+    RotateHalfConfig,
+)
+from ..modules import heuristics
+from ..ragged import (
+    DSSequenceDescriptor,
+    KVCacheConfig,
+    RaggedBatchWrapper,
+)
+from .inference_model_base import (
+    DSInferenceModelBase,
+    DSModelImplementationConfig,
+    MPType,
+)
+from ..inference_parameter import InferenceParameter
+
+try:
+    from functools import cached_property
+except ImportError:
+
+    def cached_property(func):
+        return property(func)
+
+
+class DSTransformerModelBase(DSInferenceModelBase):
+    """
+    Dimensioning properties
+    """
+
+    @property
+    @abstractmethod
+    def num_layers(self) -> int:
+        """
+        Number of the layers in the model
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def model_dim(self) -> int:
+        """
+        Size of embedding projection and residuals.
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def vocab_size(self) -> int:
+        """
+        Size of the vocabulary (including padding).
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def head_size(self) -> int:
+        """
+        Size of each attention head.
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def n_heads(self) -> int:
+        """
+        The number of query heads on the model. This should not take into account
+        any dimension reductions from model sharding.
+        """
+        ...
+
+    @property
+    def n_heads_q(self) -> int:
+        """
+        Alias to n_heads.
+        """
+        return self.n_heads
+
+    @property
+    def n_heads_kv(self) -> int:
+        """
+        The number of key and value heads on the model. For GQA or MQA, overload this attribute.
+        Otherwise it adopts MHA formulations and uses n_heads. This should not take into account
+        any dimension reductions from model sharding.
+        """
+        return self.n_heads
+
+    @property
+    @abstractmethod
+    def intermediate_dim(self) -> int:
+        """
+        The size of the (unsharded) intermediate projection dim. For a gated activation function
+        this is the size of the input to the second MLP layer. This should not take into account
+        any dimension reductions from model sharding.
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def positional_embedding_type(self) -> PositionalEmbeddingType:
+        """
+        The type of positional embedding used by the model.
+        """
+        ...
+
+    """
+    Architectural properties
+    """
+
+    @property
+    @abstractmethod
+    def activation_dtype(self) -> torch.dtype:
+        """
+        The activation dtype of the model.
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def mlp_activation_fn(self) -> ActivationType:
+        """
+        The activation function used in the MLP.
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def norm_type(self) -> NormTypeEnum:
+        """
+        The type of normalization used in the model.
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def positional_embedding_config(self) -> Optional[RotateHalfConfig]:
+        """
+        The positional embedding configuration for the model.
+        """
+        ...
+
+    """
+    Derived helpers
+    """
+
+    @cached_property
+    def n_heads_q_local(self) -> int:
+        """
+        Number of local heads post sharding.
+        """
+        return get_local_heads(self.tp_rank, self.tp_size, self.n_heads_q, self.n_heads_kv)[0]
+
+    @cached_property
+    def n_heads_kv_local(self) -> int:
+        """
+        Number of local heads post sharding.
+        """
+        return get_local_heads(self.tp_rank, self.tp_size, self.n_heads_q, self.n_heads_kv)[1]
+
+    @property
+    def gated_mlp(self) -> bool:
+        """
+        Return a boolean to determine whether the model uses a gated activation function.
+        """
+        return is_gated(self.mlp_activation_fn)
+
+    """
+    Method implementations
+    """
+
+    def __init__(self, config: DSModelImplementationConfig, engine_config: RaggedInferenceEngineConfig,
+                 base_mp_group: MPType) -> None:
+        """
+        Base implementation for initialization. By default, this will initialize
+        the traditional components of a transformer model:
+            - Embedding
+            - QKV projection
+            - Self attention
+            - Attention output projection
+            - Feed forward network
+            - Normalization
+            - Unembedding
+
+        Arguments:
+            config (DSModelImplementationConfig): Model-specific configuration. No assumptions
+                should be made about this config that are not closely tied to the specific
+                model implementation.
+            engine_config (RaggedInferenceEngineConfig): Engine configuration.
+            base_mp_group (MPType): Base communication group for Tensor-parallel inference.
+        """
+        super().__init__(config, engine_config, base_mp_group)
+
+        self.make_norm_layer()
+        self.make_qkv_layer()
+        self.make_attn_layer()
+        self.make_attn_out_layer()
+        self.make_mlp_1_layer()
+        self.make_mlp_2_layer()
+        self.make_embedding_layer()
+        self.make_unembedding_layer()
+        self._kv_cache_config = None
+
+    ######### Embedding #########
+    def make_embedding_layer(self) -> None:
+        """
+        Performs setup and creates embedding DSModule. This will set the `self.embed` attribute.
+        """
+
+        embed_config = DSEmbeddingsConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            residual_dtype=self.activation_dtype,
+            embedding_dim=self.model_dim,
+        )
+
+        self.embed = heuristics.instantiate_embed(embed_config, self._engine_config)
+
+    def transform_embedding_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Performs embedding sharding along the channels dimension.
+        """
+        # Until we can do non-contiguous all-gather, we won't shard the embedding parameters.
+        param = param.to(self.activation_dtype.value)
+        return InferenceParameter.initialize(param)
+
+    ######### Unembedding #########
+    def make_unembedding_layer(self) -> None:
+        """
+        Performs setup and creates an unembedding layer. This implementation assumes
+        normalization prior to the LM head projection. If this does not match the model's
+        implementation, override this method. This will set the ``self.unembed`` attribute.
+        """
+        unembed_dim = sharded_unembed_dim(self.vocab_size, self.tp_rank, self.tp_size)
+
+        unembed_config = DSUnembedConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            max_sequences=self._engine_config.state_manager.max_ragged_sequence_count,
+            dtype=self.activation_dtype,
+            model_dim=self.model_dim,
+            vocab_size=unembed_dim,
+            norm_type=self.norm_type,
+        )
+
+        self.unembed = heuristics.instantiate_unembed(unembed_config, self._engine_config)
+
+        if self.tp_size > 1:
+            self._comm_logits = torch.empty(self.tp_size,
+                                            self._engine_config.state_manager.max_ragged_sequence_count,
+                                            unembed_dim,
+                                            device=get_accelerator().current_device(),
+                                            dtype=self.activation_dtype.value)
+            self._return_logits = torch.empty(self._engine_config.state_manager.max_ragged_sequence_count,
+                                              self.vocab_size,
+                                              device=get_accelerator().current_device(),
+                                              dtype=self.activation_dtype.value)
+
+    def transform_unembed_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Performs sharding along the vocab dimension.
+        """
+        param = shard_unembed_param(param, self.tp_rank, self.tp_size).to(self.activation_dtype.value)
+        return InferenceParameter.initialize(param)
+
+    ######### QKV #########
+    def make_qkv_layer(self) -> None:
+        """
+        Instantiates the linear projection layer for the QKV linear layer. This sets the
+        `self.qkv` attribute.
+        """
+        out_features = qkv_out_features(self.model_dim, self.tp_rank, self.tp_size, self.head_size, self.n_heads_q,
+                                        self.n_heads_kv)
+
+        linear_config = DSLinearConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            in_channels=self.model_dim,
+            out_channels=out_features,
+            input_dtype=self.activation_dtype,
+            output_dtype=self.activation_dtype,
+        )
+
+        self.qkv = heuristics.instantiate_linear(linear_config, self._engine_config)
+
+    def transform_qkv_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Passes a QKV parameter to the underlying implementation for any necessary
+        transformations.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This may be either a bias or weight and should have
+                the shape (out_neurons, in_neurons)
+        """
+        param = shard_qkv_param(param, self.tp_rank, self.tp_size, self.head_size, self.n_heads_q, self.n_heads_kv)
+        return self.qkv.transform_param(param)
+
+    ######### Attention #########
+    def make_attn_layer(self) -> None:
+        """
+        Builds the attention layer for the model. This sets the `self.attn` attribute.
+        """
+        softmax_scale = 1.0 / (self.head_size**0.5)
+
+        attn_config = DSSelfAttentionConfig(max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+                                            n_heads_q=self.n_heads_q_local,
+                                            n_heads_kv=self.n_heads_kv_local,
+                                            head_size=self.head_size,
+                                            max_sequences=self._engine_config.state_manager.max_ragged_sequence_count,
+                                            scale_factor=softmax_scale,
+                                            input_dtype=self.activation_dtype,
+                                            output_dtype=self.activation_dtype,
+                                            positional_embedding_type=self.positional_embedding_type,
+                                            positional_embedding_config=self.positional_embedding_config)
+
+        self.attn = heuristics.instantiate_attention(attn_config, self._engine_config)
+
+    def get_kv_requirements(self, sequence: DSSequenceDescriptor, max_new_tokens: int,
+                            max_new_blocks: int) -> Tuple[int, int]:
+        """
+        See ``DSInferenceModelBase.get_kv_requirements`` for documentation.
+
+        This method assumes an autoregressive dense attention pattern. Override this method
+        if this does not match the model's attention pattern.
+        """
+        total_tokens = sequence.seen_tokens + max_new_tokens
+        req_blocks = ceil_div(total_tokens, self.attn.kv_block_size)
+        block_lim = req_blocks - sequence.cur_allocated_blocks
+
+        if block_lim <= max_new_blocks:
+            return max_new_tokens, block_lim
+
+        token_capacity = (max_new_blocks +
+                          sequence.cur_allocated_blocks) * self.attn.kv_block_size - sequence.seen_tokens
+
+        return token_capacity, max_new_blocks
+
+    def get_remaining_block_capacity(self, sequence: DSSequenceDescriptor) -> int:
+        return sequence.seen_tokens % self.attn.kv_block_size
+
+    def maybe_allocate_kv(self, sequence: DSSequenceDescriptor, n_new_tokens: int) -> None:
+        """
+        See ``DSInferenceModelBase.maybe_allocate_kv`` for documentation.
+
+        This method assumes an autoregressive dense attention pattern. Override this method
+        if this does not match the model's attention pattern.
+        """
+        free_block = self.state_manager.free_blocks[0]
+        _, n_needed_blocks = self.get_kv_requirements(sequence, n_new_tokens, free_block)
+
+        if n_needed_blocks > 0:
+            new_blocks = self.state_manager.allocate_blocks(n_needed_blocks)
+            sequence.extend_kv_cache(new_blocks)
+
+    def kv_cache_config(self) -> Tuple[KVCacheConfig, ...]:
+        """
+        See ``DSInferenceModelBase.kv_cache_config`` for documentation.
+
+        This method assumes an autoregressive dense attention pattern. Override this method
+        if this does not match the model's attention pattern.
+        """
+        if self._kv_cache_config is None:
+            cache_shape = (self.num_layers, self.n_heads_kv_local, self.head_size)
+            max_blocks = ceil_div(self.max_sequence_length, self.attn.kv_block_size)
+            self._kv_cache_config = KVCacheConfig(block_size=self.attn.kv_block_size,
+                                                  cache_shape=cache_shape,
+                                                  cache_dtype=self.activation_dtype,
+                                                  max_blocks_per_allocation_group=max_blocks)
+        return (self._kv_cache_config, )
+
+    def prepare_batch(self, wrapped_batch: RaggedBatchWrapper) -> None:
+        """
+        See ``DSInferenceModelBase.prepare_batch`` for documentation.
+
+        This method assumes an autoregressive dense attention pattern. Override this method
+        if this does not match the model's attention pattern.
+        """
+        self.attn.build_atoms(wrapped_batch)
+
+    ######### Attention output #########
+    def make_attn_out_layer(self) -> None:
+        """
+        Instantiates the linear projection layer for the attention output linear layer. This sets the
+        `self.attn_out` attribute.
+        """
+        in_features = attn_out_in_features(self.model_dim, self.tp_rank, self.tp_size, self.head_size, self.n_heads_q,
+                                           self.n_heads_kv)
+
+        linear_config = DSLinearConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            in_channels=in_features,
+            out_channels=self.model_dim,
+            input_dtype=self.activation_dtype,
+            output_dtype=self.activation_dtype,
+        )
+
+        self.attn_out = heuristics.instantiate_linear(linear_config, self._engine_config)
+
+    def transform_attn_out_param(self, param: torch.Tensor) -> Optional[InferenceParameter]:
+        """
+        Shards an attention output projection parameter and passes it to the underlying
+        implementation for any necessary transformations. This will return `None` for bias parameters
+        if they are not on TP rank 0.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This may be either a bias or weight and should have
+                the shape (out_neurons, in_neurons).
+        """
+        param = shard_attn_out_param(param, self.tp_rank, self.tp_size, self.head_size, self.n_heads_q,
+                                     self.n_heads_kv)
+
+        if param is not None:
+            param = self.attn_out.transform_param(param)
+
+        return param
+
+    ######### MLP #########
+    def make_mlp_1_layer(self) -> None:
+        """
+        Instantiates the linear projection layer for the first MLP in the feedforward network.
+        This sets the `self.mlp_1` attribute.
+        """
+        shard_size = sharded_intermediate_dim(self.intermediate_dim, self.tp_size, self.tp_rank)
+
+        linear_config = DSLinearConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            in_channels=self.model_dim,
+            out_channels=shard_size,
+            activation=self.mlp_activation_fn,
+            input_dtype=self.activation_dtype,
+            output_dtype=self.activation_dtype,
+        )
+
+        self.mlp_1 = heuristics.instantiate_linear(linear_config, self._engine_config)
+
+    def transform_mlp_1_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Shards the first MLP parameter and passes it to the underlying implementation
+        for any necessary transformations.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This may be either a bias or weight and should have
+                the shape (out_neurons, in_neurons).
+        """
+        param = shard_mlp_1_param(param, self.tp_rank, self.tp_size, gated=self.gated_mlp)
+
+        return self.mlp_1.transform_param(param)
+
+    def make_mlp_2_layer(self) -> None:
+        """
+        Instantiates the linear projection layer for the second MLP in the feedforward network.
+        This sets the `self.mlp_2` attribute.
+        """
+        shard_size = sharded_intermediate_dim(self.intermediate_dim, self.tp_size, self.tp_rank)
+
+        linear_config = DSLinearConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            in_channels=shard_size,
+            out_channels=self.model_dim,
+            input_dtype=self.activation_dtype,
+            output_dtype=self.activation_dtype,
+        )
+
+        self.mlp_2 = heuristics.instantiate_linear(linear_config, self._engine_config)
+
+    def transform_mlp_2_param(self, param: torch.Tensor) -> Optional[InferenceParameter]:
+        """
+        Shards the second MLP parameter and passes it to the underlying implementation
+        for any necessary transformations. This will return `None` for bias parameters
+        if they are not on TP rank 0.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This may be either a bias or weight and should have
+                the shape (out_neurons, in_neurons).
+        """
+        param = shard_mlp_2_param(param, self.tp_rank, self.tp_size)
+
+        if param is not None:
+            param = self.mlp_2.transform_param(param)
+
+        return param
+
+    ######### Norm #########
+    def make_norm_layer(self) -> None:
+        """
+        Instantiates the normalization layer for the model. This sets the `self.norm` attribute.
+
+        TODO(cmikeh2): In the future we'll distinguish between the different norm objects,
+        but for now we'll just use the same one for all of them.
+        """
+        norm_config = DSNormConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            type=self.norm_type,
+            channels=self.model_dim,
+            residual_dtype=self.activation_dtype,
+            input_dtype=self.activation_dtype,
+            output_dtype=self.activation_dtype,
+        )
+
+        self.norm = heuristics.instantiate_pre_norm(norm_config, self._engine_config)
+
+    def transform_norm_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Passes a normalization parameter to the underlying implementation for any
+        necessary transformations.
+
+        TODO(cmikeh2): In the future we'll distinguish between the different norm objects,
+        but for now we'll just use the same one for all of them.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This may be either a bias or weight and should have
+                shape (model_dim,)
+        """
+        return self.norm.transform_param(param)
+
+
+class DSMoETransformerModelBase(DSTransformerModelBase):
+
+    @property
+    def n_experts(self) -> int:
+        """
+        Return the number of experts in the model.
+        """
+        raise NotImplementedError("Attempted to access an unimplemented number of experts")
+
+    @property
+    def n_top_k(self) -> int:
+        """
+        Number of experts per token.
+        """
+        raise NotImplementedError("Attempted to access an unimplemented number of experts per token")
+
+    @property
+    def normalize_expert_scores(self) -> bool:
+        """
+        Whether to normalize expert scores. If true, sum(expert_scores) = 1.
+        """
+        raise NotImplementedError("Attempted to access an unimplemented normalization flag")
+
+    def make_moe_layer(self) -> None:
+        """
+        Instantiates the MoE layer for the model. This sets the `self.moe` attribute.
+        """
+        sharded_dim = sharded_intermediate_dim(self.intermediate_dim, self.tp_size, self.tp_rank)
+
+        moe_config = DSMoEConfig(
+            max_tokens=self._engine_config.state_manager.max_ragged_batch_size,
+            model_dim=self.model_dim,
+            intermediate_features=sharded_dim,
+            activation=self.mlp_activation_fn,
+            n_experts=self.n_experts,
+            top_k=self.n_top_k,
+            input_dtype=self.activation_dtype,
+            output_dtype=self.activation_dtype,
+            normalize_scores=self.normalize_expert_scores,
+        )
+
+        self.moe = heuristics.instantiate_moe(moe_config, self._engine_config)
+
+    def transform_moe_gate_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Passes a MoE gate parameter to the underlying implementation for any necessary transformations.
+
+        TODO(cmikeh2): This will need to be updated/overridden for expert parallelism.
+        """
+        return self.moe.transform_gate_param(param)
+
+    def transform_moe_mlp_1_param(self, param: torch.Tensor) -> InferenceParameter:
+        """
+        Shards the first MoE param and passes it to the underlying implementation. Since it's possible for an architecture
+        to have both MoE and non-MoE layers, this can't be overloaded on the MLP1 transform. Furthermore, since both
+        the MoE DSModule owns both MLP1 and MLP2, under certain sharding conditions it's not possible for the model implementation
+        to infer from the shape whether to perform a different transformation based on MLP1 or MLP2. This (and the below)
+        separations are intended to solve both these issues.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This should have shape (n_experts, out_neurons, in_neurons).
+        """
+        param = shard_mlp_1_param(param, self.tp_rank, self.tp_size, gated=self.gated_mlp, is_moe=True)
+
+        return self.moe.transform_moe_mlp_1_param(param)
+
+    def transform_moe_mlp_2_param(self, param: torch.Tensor) -> Optional[torch.Tensor]:
+        """
+        Shards the second MoE param and passes it to the underlying implementation. See the above for context on why this API
+        exists.
+
+        This will return `None` for expert bias params not on TP rank 0. NOTE(cmikeh2): Does it make sense to round-robin assign?
+        My intuition is that this will make debugging much more difficult for minimal memory reduction.
+
+        Args:
+            param (torch.Tensor): The parameter to transform. This should have shape (n_experts, out_neurons, in_neurons).
+        """
+        param = shard_mlp_2_param(param, self.tp_rank, self.tp_size, is_moe=True)
+
+        if param is not None:
+            param = self.moe.transform_moe_mlp_2_param(param)
+
+        return param

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/layer_container_base.py

@@ -0,0 +1,355 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import re
+from typing import Type
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from .parameter_base import ParameterBase, ParametrizedList
+from ..inference_parameter import InferenceParameter
+
+# Currently have dependency loops for the type hints.
+InferenceModel = Type["InferenceModel"]
+LayerContainer = Type["LayerContainer"]
+
+MAPPING_KEY = "PARAM_MAPPING"
+PLIST_HELPERS = "_ds_plist_strip_vals"
+
+
+def make_finalization_callback(all_names: str):
+    """
+    Helper method for building the finalization callback for a LayerContainer. This
+    is not client code and should not be used or called directly.
+    """
+
+    def finalization_callback(self, param: ParameterBase, finalized_param: torch.Tensor) -> None:
+        """
+        Callback for when a parameter is finalized.
+        """
+        self._finalized_params += 1
+
+        for name in all_names:
+            if getattr(self, name) is param:
+                setattr(self, name, finalized_param)
+
+    return finalization_callback
+
+
+class LayerMetaclass(type):
+    """
+    MetaClass for the LayerContainer base class. This class will parse the annotations
+    of the class that correspond to `ParameterBase` and create None initializers for each
+    as well as a finalization callback that for when each `ParameterBase` is finalized
+    and should be replaced with a Tensor.
+    """
+
+    def __new__(cls, clsname, bases, attrs):
+
+        annotations = attrs.get("__annotations__", {})
+
+        for base in bases:
+            # We'll pick up all annotations on any base classes. This will allow us to
+            # to use inheritance to share common parameter groups in base classes.
+            if hasattr(base, "__annotations__"):
+                annotations.update(base.__annotations__)
+
+            if hasattr(base, MAPPING_KEY):
+                if MAPPING_KEY not in attrs:
+                    # This is likely a fail state. If a parent has MAPPING KEY but the child does
+                    # not, then we're guaranteed only a subset of the parameters will be mapped.
+                    attrs[MAPPING_KEY] = {}
+                attrs[MAPPING_KEY].update(getattr(base, MAPPING_KEY))
+
+        all_names = [name for name, annotation in annotations.items() if issubclass(annotation, ParameterBase)]
+
+        if MAPPING_KEY in attrs:
+            # If we have a mapping key at all, then we will enter the validation mode for building
+            # helpers for mapping and ensuring we have complete mapping.
+
+            # First we'll build a flat list of every dependency for this layer.
+            all_deps = set()
+            for name in all_names:
+                parameter_deps = [
+                    name for name, annotation in annotations[name].__annotations__.items()
+                    if issubclass(annotation, (torch.Tensor, ParametrizedList))
+                ]
+
+                all_deps.update([f"{name}.{dep}" for dep in parameter_deps])
+
+            # Create static helper for doing the string processing only once.
+            attrs[PLIST_HELPERS] = []
+
+            # Iterate over all the mappings
+            for src_name, target_or_targets in attrs[MAPPING_KEY].items():
+                if isinstance(target_or_targets, str):
+                    target_or_targets = [target_or_targets]
+
+                actual_targets = []
+                for target_name in target_or_targets:
+                    base_dependency, dependency_attr = target_name.split(".")
+
+                    # Check for invalid mappings
+                    if base_dependency not in all_names:
+                        raise ValueError(
+                            "Target parameter \"{}\" not found in this layer. Valid targets are {}".format(
+                                base_dependency, all_names))
+                    if dependency_attr not in annotations[base_dependency].__annotations__:
+                        # This check is not universal (see below) if a single dependency is being
+                        # mapped to by a single row.
+                        raise ValueError(
+                            "Target dependency \"{}\" not found on parameter \"{}\". Valid targets are {}".format(
+                                dependency_attr, base_dependency, annotations[base_dependency].__annotations__.keys()))
+                    if target_name not in all_deps:
+                        raise ValueError(
+                            "Target dependency \"{}\" was targeted with multiple mapping rules.".format(target_name))
+
+                    # If we've made it this far, the dependency definitely exists.
+                    actual_targets.append(annotations[base_dependency].__annotations__[dependency_attr])
+
+                    all_deps.remove(target_name)
+
+                are_plists = [issubclass(target, ParametrizedList) for target in actual_targets]
+                if all(are_plists):
+                    # We can do direct sets on everything but ParametrizedLists, so we'll only explicitly
+                    # handle these here.
+                    # TODO(cmikeh2): SPLIT, error if more than 1
+                    glob_count = src_name.count("*")
+                    if glob_count > 1:
+                        raise ValueError(
+                            "ParametrizedList index inference can only work with a single glob: {}".format(src_name))
+                    elif glob_count == 0:
+                        raise ValueError(
+                            "Must have wildcard (*) in source name for ParametrizedList mapping: {}".format(src_name))
+
+                    wildcard_idx = src_name.find("*")
+                    prefix = src_name[:wildcard_idx]
+                    suffix = src_name[wildcard_idx + 1:]
+                    attrs[PLIST_HELPERS].append((prefix, suffix, target_or_targets))
+                elif any(are_plists):
+                    raise ValueError("Cannot mix ParametrizedLists and Tensors in a single mapping rule.")
+
+            if len(all_deps) > 0:
+                raise ValueError(
+                    "A parameter mapping was provided for {}, but the following dependencies were not mapped: {}".
+                    format(clsname, all_deps))
+
+        attrs["finalization_callback"] = make_finalization_callback(all_names)
+
+        new_obj = super().__new__(cls, clsname, bases, attrs)
+
+        setattr(new_obj, "_n_params", len(all_names))
+        setattr(new_obj, "_annotation_attrs", all_names)
+
+        return new_obj
+
+    def __call__(cls, *args, **kwargs):
+        instance = cls.__new__(cls, *args, **kwargs)
+        instance.__init__(*args, **kwargs)
+
+        for name, annotation in instance.__annotations__.items():
+            if issubclass(annotation, ParameterBase):
+                # TODO(cmikeh2): Do we want to make this a property
+                # It might also make sense to do this in the base class __init__
+                # but since it is tied with the changes made in __new__ it feels
+                # to me like it should be here.
+                setattr(instance, name, annotation(instance.inference_model, instance))
+
+        return instance
+
+
+class LayerContainer(metaclass=LayerMetaclass):
+    """
+    Abstract base class for containing model parameters.
+
+    This is primarily a guidance abstraction since we do not put any restrictions
+    on how the parameters are stored.
+
+    To use this class, annotate the class with `ParameterBase` subclasses and give them
+    names. As a checkpoint is loaded into this container, the `ParameterBase` instances
+    will be replaced with realized Tensors as soon as each of their dependencies are met.
+
+    To enable automatic mapping, add a static attribute `PARAM_MAPPING` to the class
+    definition. This should be a dictionary mapping from a source string to one or
+    more dependencies.
+
+    ```python
+    class MyLayer(LayerContainer):
+        PARAM_MAPPING = {
+            "path.to.param.dependency", "container_param_1.dependency",
+            "path.to.param2.dependency", "container_param_2.dependency",
+            "path.to.param3.*.dependency", "container_param_3.list_dependency"
+        }
+
+        ...
+    ```
+    """
+
+    def __init__(self, model: InferenceModel) -> None:
+        """
+        Initialization of the LayerContainer. This method does not need to be overridden
+        for any children classes.
+
+        Args:
+            model (InferenceModel): Inference model that will be used to shard and transform
+                parameters correctly, as well as provide specific information about the model
+                for `ParameterizedList`s that may be part of one of the member `ParameterBase`s.
+        """
+        self.inference_model = model
+        self._finalized_params = 0
+
+    def _initialization_checker(self, check_device: bool = True) -> bool:
+        """
+        Returns whether or not all parameters have been initialized and transformed by
+        the model. Once this returns True, all the `ParameterBase` instances will be
+        torch.Tensors.
+        """
+        if self._finalized_params != self.n_params:
+            return False
+
+        for name in self._annotation_attrs:
+            tensor = getattr(self, name)
+            if tensor is None:
+                continue
+            elif not isinstance(tensor, InferenceParameter):
+                raise ValueError("Layer should be finalized, but {} ({}) is neither InferenceParameter or None".format(
+                    name, type(tensor)))
+            elif check_device and tensor.device != torch.device(get_accelerator().current_device()):
+                raise RuntimeError("Layer should be finalized, but {} is not on device {}".format(
+                    name,
+                    get_accelerator().current_device()))
+        return True
+
+    @property
+    def is_populated(self) -> bool:
+        """
+        Returns whether or not all parameters have been populated by the checkpoint engine, but
+        does not validat the parameters are on the correct device.
+        """
+        return self._initialization_checker(check_device=False)
+
+    @property
+    def is_initialized(self) -> bool:
+        """
+        Returns whether or not all parameters have been initialized and transformed by
+        the model and are located on the appropriate device. Once this returns True, all
+        the `ParameterBase` instances ``InferenceParameter``s or explicitly set to ``None``.
+        """
+        return self._initialization_checker()
+
+    @property
+    def n_params(self) -> int:
+        """
+        The number of parameters this container holds. This is a read-only value
+        that is set by the metaclass.
+        """
+        return self._n_params
+
+    @property
+    def annotation_attrs(self) -> list:
+        return self._annotation_attrs
+
+    @property
+    def mapping_params(self) -> dict:
+        return getattr(self.__class__, MAPPING_KEY, {})
+
+    @property
+    def plist_helpers(self) -> list:
+        return getattr(self.__class__, PLIST_HELPERS, [])
+
+    def direct_injection(self, name: str, tensor: InferenceParameter) -> None:
+
+        if name not in self._annotation_attrs:
+            raise ValueError(f"Cannot directly inject {name}, not a valid parameter.")
+
+        setattr(self, name, tensor)
+        self._finalized_params += 1
+
+    def set_dependency(self, dep_name: str, dep_value: torch.Tensor) -> None:
+        """
+        Set dependency can be used for managing dependencies when a mapping is provided
+        in the class definition for the layer. The dep_name here should have any prefix
+        for transformer layers removed (such as model.layers.*.attn.qkv.weight -> attn.qkv.weight).
+
+        Args:
+            dep_name (str): The name of the dependency to set.
+            dep_value (torch.Tensor): The value to set the dependency to.
+        """
+
+        def get_dep_name_target(dep_name: str) -> str:
+            """
+            Helper method for getting the target name for a dependency from the
+            mapping params. Tries to match exact string first, then looks for
+            wildcards and attempts regex matching. Will return empty string if
+            no match found.
+            """
+            if dep_name in self.mapping_params:
+                # If we have an exact match, it's a direct mapping and we can
+                # immediately set the value.
+                return self.mapping_params[dep_name]
+
+            matched_targets = []
+            for key, target in self.mapping_params.items():
+                regex_key = key.replace("*", ".*")
+                if re.match(regex_key, dep_name):
+                    matched_targets.append(target)
+            if len(matched_targets) > 1:
+                raise ValueError(f"Multiple targets matched for dependency {dep_name}: {matched_targets}")
+            if matched_targets:
+                return matched_targets[0]
+            return ""
+
+        if dep_name in self.mapping_params:
+            # If we have an exact match, it's a direct mapping and we can immediately set
+            # the value.
+            target = self.mapping_params[dep_name]
+
+            # Convert single targets to a list for consistency
+            if isinstance(target, str):
+                target = [target]
+
+            for target_name in target:
+                # Double setting doesn't set the attribute correctly, so we do a getattr then setattr
+                target_param_name, target_dependency_name = target_name.split(".")
+                target_param = getattr(self, target_param_name)
+                setattr(target_param, target_dependency_name, dep_value)
+            return
+
+        # Otherwise we need to map to one of the parameter lists.
+        for prefix, suffix, dests in self.plist_helpers:
+            if dep_name.startswith(prefix) and dep_name.endswith(suffix):
+                # We have a match, so we can set the value.
+                target_idx = int(dep_name[len(prefix):-len(suffix)])
+
+                # Convert single targets to a list for consistency
+                if isinstance(dests, str):
+                    dests = [dests]
+
+                for dest in dests:
+                    target_param_name, target_dependency_name = dest.split(".")
+                    target_param = getattr(self, target_param_name)
+                    target_dependency = getattr(target_param, target_dependency_name)
+                    target_dependency[target_idx] = dep_value
+                return
+
+        # TODO: Refactor this with the help of cmikeh2
+        # We should be able to combine this with the wildcard matching above.
+        target = get_dep_name_target(dep_name)
+        if target:
+            # Convert single targets to a list for consistency
+            if isinstance(target, str):
+                target = [target]
+
+            for target_name in target:
+                # Double setting doesn't set the attribute correctly, so we do a getattr then setattr
+                target_param_name, target_dependency_name = target_name.split(".")
+                target_param = getattr(self, target_param_name)
+                setattr(target_param, target_dependency_name, dep_value)
+            return
+
+        raise ValueError(
+            "Could not find a mapping for dependency \"{}\". Check that it is included in the ``MAPPING_PARAMS``. See docstring for more on ``MAPPING_PARAMS``"
+            .format(dep_name))

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/mistral/__init__.py

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

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/mistral/model.py

@@ -0,0 +1,207 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Iterable, Optional, Tuple
+
+import torch
+
+import deepspeed.comm as dist
+
+from ...allocator import empty_from
+from ...inference_utils import ActivationType, DtypeEnum
+from ...model_implementations import *
+from ...modules.configs import *
+from ...modules.interfaces import *
+from ...ragged import RaggedBatchWrapper
+
+from .container import MistralNonTransformerContainer, MistralTransformerContainer
+
+
+class MistralInferenceModel(DSTransformerModelBase):
+    """
+    Inference model implementation for ragged batching for Mistral models.
+    """
+
+    _non_transformer: Optional[MistralNonTransformerContainer]
+    """
+    Embed + unembed container. Specializing the type annotation.
+    """
+
+    _transformer: Optional[Iterable[MistralTransformerContainer]]
+    """
+    Per-layer transformer container. Specializing the type annotation.
+    """
+    """
+    Properties ineherited from `DSInferenceModelBase`
+    """
+
+    @property
+    def max_sequence_length(self) -> int:
+        return self._config.max_seq_length
+
+    """
+    Properties ineherited from `DSTransformerModelBase`
+    """
+
+    @property
+    def num_layers(self) -> int:
+        return self._config.num_hidden_layers
+
+    @property
+    def model_dim(self) -> int:
+        return self._config.hidden_size
+
+    @property
+    def vocab_size(self) -> int:
+        return self._config.vocab_size
+
+    @property
+    def head_size(self) -> int:
+        return self.model_dim // self.n_heads
+
+    @property
+    def n_heads(self) -> int:
+        return self._config.num_attention_heads
+
+    @property
+    def intermediate_dim(self) -> int:
+        return self._config.intermediate_size
+
+    @property
+    def n_heads_kv(self) -> int:
+        return self._config.num_key_value_heads
+
+    @property
+    def activation_dtype(self) -> DtypeEnum:
+        if self._config.torch_dtype == torch.float16:
+            return DtypeEnum.fp16
+        elif self._config.torch_dtype == torch.bfloat16:
+            return DtypeEnum.bf16
+        else:
+            raise NotImplementedError("Only fp16 and bf16 are supported")
+
+    @property
+    def mlp_activation_fn(self) -> ActivationType:
+        activation = self._config.hidden_act.lower()
+        if activation == "gelu":
+            return ActivationType.GEGLU
+        elif activation == "relu":
+            return ActivationType.ReGLU
+        elif activation == "gegelu":
+            return ActivationType.GEGLU
+        elif activation == "silu":
+            return ActivationType.SiGLU
+        else:
+            raise NotImplementedError(f"Activation {activation} not supported")
+
+    @property
+    def norm_type(self) -> NormTypeEnum:
+        return NormTypeEnum.RMSNorm
+
+    @property
+    def positional_embedding_type(self) -> PositionalEmbeddingType:
+        return PositionalEmbeddingType.rotate_half
+
+    @property
+    def positional_embedding_config(self) -> Optional[RotateHalfConfig]:
+        return RotateHalfConfig(theta_base=self._config.rope_theta)
+
+    """
+    Forward implementations
+    """
+
+    def _forward_embed(self, ragged_batch: RaggedBatchWrapper) -> torch.Tensor:
+        """
+        Performs the embedding lookup prior to running the transformer of the model.
+
+        Arguments:
+            ragged_batch (RaggedBatchWrapper): The batch to embed.
+
+        Returns:
+            torch.Tensor: The embedded batch.
+        """
+        embed = self.embed(ragged_batch, self._non_transformer.word_emb)
+
+        if embed.shape[-1] != self.model_dim:
+            raise ValueError(f"Embedding output shape {embed.shape} does not match model_dim {self.model_dim}")
+
+        return embed
+
+    def _forward_transformer(self, layer_idx: int, residual: torch.Tensor, hidden_states: torch.Tensor,
+                             ragged_batch_info: RaggedBatchWrapper) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Executes one (slightly offset) layer of the transformer. This implementation does a peak-ahead
+        optimization to fuse the layer norm of the next layer into the current layer.
+
+        Arguments:
+            layer_idx (int): The index of the layer to execute.
+            residual (torch.Tensor): The residual tensor from the previous layer.
+            hidden_states (torch.Tensor): The hidden states from the previous layer. This is the
+                hidden states after pre normalization.
+            ragged_batch_info (RaggedBatchWrapper): The batch metadata.
+        """
+        # TODO(cmikeh2): Distribute ragged_batch_info to all modules
+
+        cur_params = self._transformer[layer_idx]
+        kv_cache = self.state_manager.get_cache(layer_idx)
+
+        hidden_states = self.qkv(hidden_states, cur_params.qkv_w, b=None)
+        hidden_states = self.attn(hidden_states, kv_cache, ragged_batch_info)
+        hidden_states = self.attn_out(hidden_states, cur_params.attn_out_w, b=None)
+
+        if self.tp_size > 1:
+            dist.all_reduce(hidden_states, group=self._base_mp_group)
+
+        residual, hidden_states = self.norm(residual, hidden_states, cur_params.mlp_norm_gamma, beta=None)
+
+        # Should be configurable in the future
+        hidden_states = self.mlp_1(hidden_states, cur_params.mlp_1_w, b=None)
+        hidden_states = self.mlp_2(hidden_states, cur_params.mlp_2_w, b=None)
+
+        if self.tp_size > 1:
+            dist.all_reduce(hidden_states, group=self._base_mp_group)
+
+        if layer_idx != self.num_layers - 1:
+            next_params = self._transformer[layer_idx + 1]
+            residual, hidden_states = self.norm(residual, hidden_states, next_params.attn_norm_gamma, beta=None)
+        else:
+            # On last layer, we just need to perform the residual add. Adding into the residual
+            # here is safe.
+            residual.add_(hidden_states)
+
+        return residual, hidden_states
+
+    def _forward_unembed(self, hidden_states: torch.Tensor, ragged_batch_info: RaggedBatchWrapper) -> torch.Tensor:
+        """
+        Performs unembedding of the hidden states to logits. This will only sample the final
+        token of each sequence.
+        """
+        logits = self.unembed(hidden_states,
+                              self._non_transformer.word_unembed,
+                              ragged_batch_info,
+                              gamma=self._non_transformer.final_norm)
+
+        if self.tp_size > 1:
+            comm_buffer = empty_from(self._comm_logits, (self.tp_size, logits.shape[0], logits.shape[1]))
+            full_logits = empty_from(self._return_logits, (logits.shape[0], self.vocab_size))
+
+            dist.all_gather_into_tensor(comm_buffer, logits, group=self._base_mp_group)
+
+            full_logits.copy_(comm_buffer.permute(1, 0, 2).reshape(logits.shape[0], self.vocab_size))
+
+            return full_logits
+        else:
+            return logits
+
+    def forward(self, wrapped_batch: RaggedBatchWrapper) -> torch.Tensor:
+
+        residual = self._forward_embed(wrapped_batch)
+
+        residual, hidden_states = self.norm(residual, None, self._transformer[0].attn_norm_gamma, beta=None)
+
+        for layer_idx in range(self.num_layers):
+            residual, hidden_states = self._forward_transformer(layer_idx, residual, hidden_states, wrapped_batch)
+
+        return self._forward_unembed(residual, wrapped_batch)