Add files using upload-large-folder tool

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

@@ -0,0 +1,19 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .inference_model_base import DSInferenceModelBase
+from .inference_transformer_base import DSTransformerModelBase, DSMoETransformerModelBase
+from .inference_policy_base import InferenceV2Policy, ContainerMap
+from .sharding import *
+
+# Model Implementations
+from .llama_v2 import *
+from .opt import *
+from .mistral import *
+from .mixtral import *
+from .falcon import *
+from .phi import *
+from .qwen import *
+from .qwen_v2 import *

venv/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)

venv/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)

venv/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)

venv/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)

venv/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)

venv/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/falcon/policy.py

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Any
+
+from ...config_v2 import RaggedInferenceEngineConfig
+from ..inference_policy_base import ContainerMap, InferenceV2Policy
+from .container import FalconNonTransformerContainer, FalconTransformerContainer
+from .container import FalconNewArchTransformerContainer
+from .model import FalconInferenceModel
+
+
+class FalconPolicy(InferenceV2Policy):
+
+    def instantiate_model(self, engine_config: RaggedInferenceEngineConfig, mp_group: Any) -> FalconInferenceModel:
+        return FalconInferenceModel(config=self._model_config, engine_config=engine_config, base_mp_group=mp_group)
+
+    def build_container_map(self) -> ContainerMap:
+        map = ContainerMap()
+
+        trans_container_cls = FalconNewArchTransformerContainer if self._model_config.new_decoder_architecture else FalconTransformerContainer
+        transformer_containers = [trans_container_cls(self.model) for _ in range(self.model.num_layers)]
+
+        map.set_transformer_params(['transformer.h'], transformer_containers)
+
+        map.set_non_transformer_params(FalconNonTransformerContainer(self.model))
+
+        map.set_unmapped_params(
+            [f'model.layers.{i}.self_attn.rotary_emb.inv_freq' for i in range(self.model.num_layers)])
+
+        return map

venv/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)

venv/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/inference_model_base.py

@@ -0,0 +1,272 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from abc import ABC, abstractmethod
+from typing import Iterable, Optional, Tuple, Type
+
+import torch
+
+import deepspeed.comm as dist
+from ..ragged import DSStateManager, RaggedBatchWrapper
+from ..ragged.manager_configs import KVCacheConfig
+from ..ragged import DSSequenceDescriptor
+from ..model_implementations.layer_container_base import LayerContainer
+from ..config_v2 import RaggedInferenceEngineConfig
+from .flat_model_helpers import ModelMetadata
+
+try:
+    from functools import cached_property
+except ImportError:
+
+    def cached_property(func):
+        return property(func)
+
+
+"""
+This abstract class defines the interfaces that a model implementation should implement
+in order to include anything that may be called by the engine. Most models should be able
+to inherit from `DSInferenceTransformerModelBase` to reduce implementation work so it is recommended
+to begin there.
+"""
+"""
+Placeholder for typing the model config, which can vary based on model implementation/
+"""
+DSModelImplementationConfig = Type['DSModelImplementationConfig']
+"""
+Placeholder for typing the distributed comm object.
+
+TODO(cmikeh2): Replace when we have a more defined API for the inference communication system.
+"""
+MPType = Type["MPType"]
+
+
+class DSInferenceModelBase(torch.nn.Module, ABC):
+    """
+    Implementation of a model for inference composable with ragged batching.
+    """
+
+    _config: DSModelImplementationConfig
+    """
+    Model-specific configuration. No abstraction surrounds this yet.
+    """
+
+    _engine_config: RaggedInferenceEngineConfig
+    """
+    Engine configuration.
+    """
+
+    _base_mp_group: MPType
+    """
+    Base communication group for Tensor-parallel inference.
+    """
+
+    _non_transformer: Optional[LayerContainer]
+    """
+    Abstract container for storing both embedding (pre-transformer) and unembedding (post-transformer)
+    parameters. This attribute should be None at model instantiation until the Policy sets
+    the model parameters. These parameters are grouped together since many model implementations
+    will tie the embedding and unembedding parameters together.
+    """
+
+    _transformer: Optional[Iterable[LayerContainer]]
+    """
+    List of abstract containers (1 per layer) for storing transformer (transformer)
+    parameters. This attribute should be None at model instantiation until the Policy
+    sets the model parameters.
+    """
+
+    state_manager: Optional[DSStateManager]
+    """
+    Since the state manager is lazy initialized, by the engine, it is not guaranteed to be present
+    until full initialization.
+    """
+
+    def __init__(self, config: DSModelImplementationConfig, engine_config: RaggedInferenceEngineConfig,
+                 base_mp_group: MPType) -> None:
+        """
+        Minimal initialization of the model.
+
+        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__()
+        self._config = config
+        self._engine_config = engine_config
+        self._base_mp_group = base_mp_group
+
+        # Set to None until the Policy sets the model parameters
+        self._non_transformer = None
+        self._transformer = None
+        self._flattened_param_buffer = None
+        self._flattened_param_metadata = None
+
+    @property
+    def config(self) -> DSModelImplementationConfig:
+        """
+        The model config.
+        """
+        return self._config
+
+    def set_parameters(self, transformer: Iterable[LayerContainer], non_transformer: LayerContainer,
+                       flattened_param_buffer: torch.Tensor, flattened_param_metadata: ModelMetadata):
+        """
+        Set the model parameters for the embedding, transformer, and unembedding containers.
+        """
+        self._transformer = transformer
+        self._non_transformer = non_transformer
+        self._flattened_param_buffer = flattened_param_buffer
+        self._flattened_param_metadata = flattened_param_metadata
+
+    def set_state_manager(self, state_manager: DSStateManager):
+        """
+        Sets the state manager attribute. This is called by the inference engine after
+        the model is fully initialized.
+        """
+        self.state_manager = state_manager
+
+    @cached_property
+    def tp_rank(self) -> int:
+        """
+        The rank of the current process.
+
+        # TODO(cmikeh2): Kind of a hack right now, but this is too verbose to use at
+        the frequency we need.
+        """
+        return dist.get_rank(group=self._base_mp_group)
+
+    @cached_property
+    def tp_size(self) -> int:
+        """
+        The total number of processes.
+
+        # TODO(cmikeh2): Kind of a hack right now, but this is too verbose to use at
+        the frequency we need.
+        """
+        return dist.get_world_size(group=self._base_mp_group)
+
+    @property
+    def model_config(self):
+        """
+        The model config.
+        """
+        return self._config
+
+    @property
+    def engine_config(self):
+        """
+        The engine config.
+        """
+        return self._engine_config
+
+    @property
+    def flattened_params(self) -> Optional[torch.Tensor]:
+        """
+        The flattened parameter buffer.
+        """
+        return self._flattened_param_buffer
+
+    @property
+    def flattened_param_metadata(self) -> Optional[ModelMetadata]:
+        """
+        The flattened parameter metadata.
+        """
+        return self._flattened_param_metadata
+
+    @abstractmethod
+    def get_kv_requirements(self, sequence: DSSequenceDescriptor, max_new_tokens: int,
+                            max_new_blocks: Tuple[int, ...]) -> Tuple[int, torch.Tensor]:
+        """
+        Given a sequence and the number of new tokens in the sequence, determine the
+        number of new KV blocks needed to support the sequence. This method is
+        used to help the engine provide schedulability APIs and can be used as a helper
+        for ``maybe_allocate_kv``.
+
+        Args:
+            sequence (DSSequenceDescriptor): The sequence for which to allocate KV-storage.
+            max_new_tokens (int): Maximum number of tokens to hypothetically schedule.
+            max_new_blocks (int): Maximum number of blocks to hypothetically allocate.
+
+        Returns:
+            Tuple[int, torch.Tensor]: The tuple of number of tokens scheduled and number
+                of blocks allocated (per KV cache). In general, only one of these numbers will
+                match the corresponding input argument, but this is not guaranteed.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_remaining_block_capacity(self, sequence: DSSequenceDescriptor) -> int:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def maybe_allocate_kv(self, sequence: DSSequenceDescriptor, n_new_tokens: int) -> None:
+        """
+        Given a sequence and the number of new tokens in the sequence, determine
+        whether or not additional KV-storage is needed and allocate it if so.
+
+        Args:
+            sequence (DSSequenceDescriptor): The sequence for which to allocate KV-storage.
+            n_new_tokens (int): The number of new tokens in the sequence.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def kv_cache_config(self) -> Tuple[KVCacheConfig, ...]:
+        """
+        Return the KV-cache configuration for this model. This should be a tuple of one or more
+        KVCacheConfig objects (one for each distinct cache group).
+        """
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def max_sequence_length(self) -> int:
+        """
+        The maximum sequence length supported by the model.
+        """
+        ...
+
+    def maybe_free_kv(self, sequence: DSSequenceDescriptor) -> None:
+        """
+        After completing a forward pass, determine whether or not the there are any KV blocks
+        that maybe freed since they are no longer in use.
+
+        Consider the following example:
+
+        We have a block size of 4 and a local window size of 8. At the beginning of the forward
+        pass there 10 tokens had been seen and the new forward has a size of 4. This would lend
+        itself to the following cache structure prior to the forward:
+            [[0, 1, 2*, 3*] [4*, 5*, 6*, 7*] [8*, 9*, x, x] [x x x x]]
+        Where x's denote empty cache locations and * denote values that are needed for attention
+        of the next open slot. After the forward, the cache would look like the following:
+            [[0, 1, 2, 3] [4, 5, 6*, 7*] [8*, 9*, 10*, 11*] [12* 13* x x]]
+        In this case, the first block is no longer needed since it is not needed for any future
+        local attention windows. This function would be responsible for freeing that block.
+
+        Default behavior assumes no local patterns that require freeing and in general should
+        be sufficient.
+        """
+        pass
+
+    @abstractmethod
+    def prepare_batch(self, wrapped_batch: RaggedBatchWrapper) -> None:
+        """
+        This will be called before each forward with the intent of building forward-specific metadata
+        about a batch. The intent here is to build data structures like attention atoms without necessarily
+        needing to implement graphable kernels to do so.
+
+        Abstract so as to force model implementations to opt out of doing anything here explicitly.
+        """
+        raise NotImplementedError()
+
+    def forward(wrapped_batch: RaggedBatchWrapper) -> torch.Tensor:
+        """
+        Complete a forward pass of the model. This interface should be graphable, so it
+        should not rely on the ability to use python control flow.
+        """
+        raise NotImplementedError()

venv/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)

venv/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

venv/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))

venv/lib/python3.10/site-packages/deepspeed/inference/v2/model_implementations/parameter_base.py

@@ -0,0 +1,255 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import weakref
+from abc import abstractmethod
+from typing import Type
+
+import torch
+
+# Currently have dependency loops for the type hints.
+InferenceModel = Type["InferenceModel"]
+LayerContainer = Type["LayerContainer"]
+
+MAPPING_KEY = "PARAM_MAPPING"
+
+
+def make_param_getter(clsname, param):
+    """
+    Normal getter implementation for a property.
+    """
+
+    def param_getter(self):
+        return getattr(self, f"__{clsname}__{param}")
+
+    return param_getter
+
+
+def make_param_setter(clsname, param):
+    """
+    Setter implementation that will call complete component to potentially
+    finalize the parameter.
+    """
+
+    def param_setter(self, value):
+        setattr(self, f"__{clsname}__{param}", value)
+        self.complete_component()
+
+    return param_setter
+
+
+def make_readonly_setter():
+    """
+    Setter implementation that will raise an error if called.
+    """
+
+    def paramlist_setter(self, value):
+        raise ValueError("Cannot set a ParametrizedList directly.")
+
+    return paramlist_setter
+
+
+class ParameterMetaclass(type):
+    """
+    MetaClass for the ParameterBase base class. This class will parse the `src_params`
+    attribute and create properties for each of the dependencies. A dependency can either
+    be represented as a string, which is interpreted as a named Tensor, or a `ParametrizedList`
+    subclass.
+    """
+
+    def __new__(cls, clsname, bases, attrs):
+
+        annotations = attrs.get("__annotations__", {})
+        dependencies = {
+            name: annotation
+            for name, annotation in annotations.items() if issubclass(annotation, (torch.Tensor, ParametrizedList))
+        }
+        n_dependencies = len(dependencies)
+
+        # Create properties for each of our dependencies
+        for d_name, d_type in dependencies.items():
+            if issubclass(d_type, ParametrizedList):
+                assert hasattr(
+                    d_type, "count_attr"
+                ), "ParametrizedList must have a count_attr attribute to access on the inference module."
+                attrs[d_name] = property(make_param_getter(clsname, d_name), make_readonly_setter())
+            else:  # torch.Tensor
+                attrs[d_name] = property(make_param_getter(clsname, d_name), make_param_setter(clsname, d_name))
+
+        new_cls = super().__new__(cls, clsname, bases, attrs)
+        new_cls.n_dependencies = n_dependencies
+
+        return new_cls
+
+    def __call__(cls, *args, **kwargs):
+        new_obj = super().__call__(*args, **kwargs)
+        new_obj.__init__(*args, **kwargs)
+
+        setattr(new_obj, "dest_param", None)
+
+        # Initialize our dependences to None/empty `ParametrizedList`s
+        for name, annotation in new_obj.__annotations__.items():
+            if issubclass(annotation, ParametrizedList):
+                #TODO(jeff): update assert with this, model implementation attribute does not align or missing wrt the ParametrizedList attributes
+                assert hasattr(
+                    new_obj.inference_model, annotation.count_attr
+                ), f"new_obj={new_obj.__class__.__name__}, name={name}, annotation.count_attr={annotation.count_attr}"
+                param_list = annotation(new_obj, getattr(new_obj.inference_model, annotation.count_attr))
+                setattr(new_obj, f"__{new_obj.__class__.__name__}__{name}", param_list)
+            else:  # torch.Tensor
+                setattr(new_obj, f"__{new_obj.__class__.__name__}__{name}", None)
+
+        return new_obj
+
+
+class ParameterBase(metaclass=ParameterMetaclass):
+    """
+    A ParameterBase allows us to consolidate tracking the dependencies of loading a parameter from
+    a checkpoint into a single object. This class should not be used directly, but rather subclassed
+    and the `src_params` attribute set to a list of strings and/or `ParametrizedList`s.
+    """
+
+    # inference_model: InferenceModel
+    """
+    Inference model that will provide context on how to shard and transform the parameter.
+    """
+
+    #completed_components: int
+    """
+    How many of the layer dependencies have been met. This is used to determine when the parameter
+    is ready to be finalized. A ParametrizedList counts as a single dependency for the purposes
+    of this counter.
+    """
+
+    def __init__(self, model: InferenceModel, parent_container: LayerContainer) -> None:
+        """
+        Direct constructor. This should not be called from client code.
+
+        Args:
+            model (InferenceModel): Inference model that will be used to shard and transform the
+                parameter in `finalize`.
+            parent_container (LayerContainer): The parent container that this parameter is a member
+                of. We will build a weakref to this container to call the finalization callback.
+        """
+        self.inference_model = model
+        self.completed_components = 0
+        self.parent_container = weakref.ref(parent_container)
+
+    @abstractmethod
+    def finalize(self) -> torch.Tensor:
+        """
+        Finalize the parameter after all of its source parameters have been set. This method
+        will be automatically called when all inputs have been set. It should return the Tensor
+        with all transformations performed on it.
+        """
+        pass
+
+    def complete_component(self) -> None:
+        """
+        Mark a component as completed. This should be called by the relevant setter of a direct
+        property or a ParametrizedList. This method will automatically call `finalize` when all
+        dependencies have been met and then call the finalization callback on the parent container.
+
+        Once the finalization callback has been called, the parameter will be replaced with the
+        `dst_param` attribute on the parent container, and this instance will be destroyed.
+        """
+        self.completed_components += 1
+
+        if self.completed_components != self.n_dependencies:
+            return
+
+        finalized_param = self.finalize()
+        self.parent_container().finalization_callback(self, finalized_param)
+
+
+class ParametrizedList:
+    """
+    A ParametrizedList is a list of parameters that are dependencies
+    of a `ParameterBase` but may vary in length depending on the model
+    configuration (rather than architecture). For example, a MoE layer
+    may have different number of experts depending on the size of the model.
+
+    This class is used to manage these lists and provide integer indexing
+    of a single component rather than accessing names directly. For example,
+    it tends to be more natural to access the 8th expert with `experts[8]`
+    rather than a name like `expert_8`, especially as an attribute.
+
+    To inherit from this class, set static variables `name` and `count_attr`.
+
+    ```python
+    class MyParametrizedList(ParametrizedList):
+        count_attr: str = "my_list_count"
+    ```
+
+    In the above example, `my_list_count` should be an accessible attribute
+    of the inference model (i.e. via `self.inference_model.my_list_count`).
+
+    NOTE: There are some APIs in which this type cannot be used as if it is
+    just a list of Tensors. For example, `torch.cat(param_list)` will not work.
+    However, you can make it compatible with a tuple wrapper:
+        `torch.cat(tuple(param_list))`
+    """
+
+    n_params: int
+    """
+    Number of params this list contains.
+    """
+
+    param: ParameterBase
+    """
+    WeakRef to the owning parameter.
+    """
+
+    def __init__(self, param: ParameterBase, n_params: int) -> None:
+        """
+        Constructor. Should not be called from client code.
+
+        Args:
+            param (ParameterBase): The owning parameter.
+            n_params (int): The number of parameters this list contains. This should be
+        """
+        self.n_params = n_params
+        self.set_params = 0
+        self.param = weakref.ref(param)
+        self._params = [None] * n_params
+
+    def __getitem__(self, index):
+        return self._params[index]
+
+    def __setitem__(self, index, value):
+        if self._params[index] is not None:
+            raise ValueError("Cannot set a parameter twice.")
+
+        self._params[index] = value
+        self.set_params += 1
+
+        if self.set_params != self.n_params:
+            return
+
+        self.param().complete_component()
+
+    def __iter__(self):
+        return iter(self._params)
+
+
+def ParamList(attr: str):
+    """
+    Helper to create a subclass of ParametrizedList with the desired `count_attr`.
+
+    In this manner, we can annotate the type of a Parameter dependency with the
+    following:
+
+    ```python
+    class CustomParameter(ParameterBase):
+        dependency_list: ParamList("dependencies_count_name")
+    ```
+
+    where "dependencies_count_name" is the name of the attribute on the inference model.
+    """
+
+    class ParametrizedListInstance(ParametrizedList):
+        count_attr: str = attr
+
+    return ParametrizedListInstance

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+# Imports for registering ops
+from .attention import *
+from .linear import *
+from .post_norm import *
+from .pre_norm import *
+from .embedding import *
+from .unembed import *
+from .moe import *

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/embedding/__init__.py

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

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/embedding/ragged_embedding.py

@@ -0,0 +1,77 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Any, Dict, Optional
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from ....allocator import empty_from
+from ....inference_utils import DtypeEnum
+from ....kernels.ragged_ops import RaggedEmbeddingKernel
+from ....ragged import RaggedBatchWrapper
+from ...interfaces import DSEmbeddingBase, DSEmbeddingRegistry
+from ...configs import DSEmbeddingsConfig
+
+
+@DSEmbeddingRegistry.register_module
+class DSRaggedEmbedding(DSEmbeddingBase):
+
+    @staticmethod
+    def name():
+        return 'ragged_embedding'
+
+    @staticmethod
+    def supports_config(config: DSEmbeddingsConfig) -> bool:
+
+        if DtypeEnum(config.residual_dtype) not in [DtypeEnum.fp16, DtypeEnum.bf16, DtypeEnum.fp32]:
+            return False
+
+        if config.use_token_type:
+            return False
+
+        if config.output_normalization is not None:
+            return False
+
+        try:
+            _ = RaggedEmbeddingKernel(config.residual_dtype, torch.int32, config.embedding_dim)
+        except ValueError:
+            return False
+
+        return True
+
+    def __init__(self, config: DSEmbeddingsConfig, implementation_config: Dict[str, Any]) -> None:
+        super().__init__(config, implementation_config)
+
+        self.embed_offset = self._config.positional_offset
+
+        # TODO(cmikeh2): How do we want to avoid the int32 vs int64 issue?
+        self._ragged_embed = RaggedEmbeddingKernel(self._config.residual_dtype, torch.int32,
+                                                   self._config.embedding_dim)
+
+        self._output = torch.empty((self._config.max_tokens, self._config.embedding_dim),
+                                   dtype=self._config.residual_dtype,
+                                   device=get_accelerator().current_device())
+
+    @property
+    def output(self) -> torch.Tensor:
+        return self._output
+
+    def forward(self,
+                ragged_batch: RaggedBatchWrapper,
+                word_embeddings: torch.Tensor,
+                position_embeddings: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """
+        Parameters:
+            ragged_batch (RaggedBatchWrapper): The input ids and associated ragged batch metadata.
+            word_embeddings (torch.Tensor): The word embedding table
+        """
+        output = empty_from(self._output, (ragged_batch.tensor_toks, self._config.embedding_dim))
+        self._ragged_embed(output,
+                           ragged_batch,
+                           word_embeddings,
+                           position_embed_weight=position_embeddings,
+                           position_embed_offset=self.embed_offset)
+        return output

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/post_norm/__init__.py

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

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/post_norm/cuda_post_ln.py

@@ -0,0 +1,56 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Any, Dict, Tuple
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from ...interfaces import DSPostNormBase, DSPostNormRegistry
+from ...configs import DSNormConfig
+from ....kernels.core_ops.cuda_layer_norm.cuda_post_ln import CUDAFPPostLN
+from ....allocator import empty_from
+from ....inference_parameter import InferenceParameter
+
+
+@DSPostNormRegistry.register_module
+class DSPostLNCUDAModule(DSPostNormBase):
+
+    @staticmethod
+    def name():
+        return 'cuda_post_ln'
+
+    @staticmethod
+    def supports_config(config: DSNormConfig):
+        if len(set([config.residual_dtype, config.input_dtype, config.output_dtype])) != 1:
+            return False
+
+        try:
+            _ = CUDAFPPostLN(config.channels, config.residual_dtype)
+        except ValueError:
+            return False
+        return True
+
+    def __init__(self, config: DSNormConfig, implementation_config: Dict[str, Any]):
+        super().__init__(config, implementation_config)
+        self._fp_post_ln = CUDAFPPostLN(self._config.channels, self._config.residual_dtype, epsilon=self._config.eps)
+
+        self._output = torch.empty((config.max_tokens, config.channels),
+                                   dtype=config.output_dtype,
+                                   device=get_accelerator().current_device())
+
+    def transform_param(self, param: torch.Tensor) -> InferenceParameter:
+        param = param.to(self._config.input_dtype)
+        return InferenceParameter.initialize(param)
+
+    def forward(self, residual: torch.Tensor, hidden_in: torch.Tensor, gamma: torch.Tensor,
+                beta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Since the CUDA FP only supports all data types being the same, we will alias the residual
+        with our output.
+        """
+        self._residual_output = empty_from(self._output, residual.shape)
+        self._fp_post_ln(residual, residual, hidden_in, gamma, beta)
+        return residual, residual

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/pre_norm/cuda_pre_ln.py

@@ -0,0 +1,69 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Any, Dict, Optional, Tuple
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from ...interfaces import DSPreNormBase, DSPreNormRegistry
+from ...configs import DSNormConfig, NormTypeEnum
+from ....kernels.core_ops.cuda_layer_norm.cuda_pre_ln import CUDAFPPreLN
+from ....kernels.core_ops.cuda_layer_norm.cuda_ln import CUDAFPLN
+from ....allocator import empty_from
+from ....inference_parameter import InferenceParameter
+
+
+@DSPreNormRegistry.register_module
+class DSPreLNCUDAModule(DSPreNormBase):
+
+    @staticmethod
+    def name():
+        return 'cuda_pre_ln'
+
+    @staticmethod
+    def supports_config(config: DSNormConfig):
+        type = NormTypeEnum(config.type)
+        if type != NormTypeEnum.LayerNorm:
+            return False
+
+        if len(set([config.residual_dtype, config.input_dtype, config.output_dtype])) != 1:
+            return False
+
+        try:
+            _ = CUDAFPPreLN(config.channels, config.residual_dtype)
+        except ValueError:
+            return False
+        return True
+
+    def __init__(self, config: DSNormConfig, implementation_config: Dict[str, Any]):
+        super().__init__(config, implementation_config)
+        self._fp_pre_ln = CUDAFPPreLN(self._config.channels, self._config.residual_dtype, epsilon=self._config.eps)
+        self._fp_ln = CUDAFPLN(self._config.channels, self._config.residual_dtype, epsilon=self._config.eps)
+
+        # Buffers for the hidden output (residual is updated in-place)
+        self._hidden_output = torch.empty((config.max_tokens, config.channels),
+                                          dtype=config.output_dtype,
+                                          device=get_accelerator().current_device())
+
+    def transform_param(self, param: torch.Tensor) -> InferenceParameter:
+        param = param.to(self._config.input_dtype)
+        return InferenceParameter.initialize(param)
+
+    def forward(self, residual: torch.Tensor, hidden_in: Optional[torch.Tensor], gamma: torch.Tensor,
+                beta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Since the CUDA FP only supports all data types being the same, we will alias the residual
+        with our output.
+
+        If hidden_in is None, that means we do not need to perform the residual add and will
+        only return the hidden output modified.
+        """
+        hidden_out = empty_from(self._hidden_output, residual.shape)
+        if hidden_in is None:
+            self._fp_ln(hidden_out, residual, gamma, beta)
+        else:
+            self._fp_pre_ln(residual, hidden_out, residual, hidden_in, gamma, beta)
+        return residual, hidden_out

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/pre_norm/cuda_pre_rms.py

@@ -0,0 +1,79 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Any, Dict, Optional, Tuple
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from ...interfaces import DSPreNormBase, DSPreNormRegistry
+from ...configs import DSNormConfig, NormTypeEnum
+from ....kernels.core_ops import CUDARMSNorm, CUDARMSPreNorm
+from ....allocator import empty_from
+from ....inference_parameter import InferenceParameter
+
+
+@DSPreNormRegistry.register_module
+class DSPreRMSCUDAModule(DSPreNormBase):
+
+    @staticmethod
+    def name():
+        return 'cuda_pre_rms'
+
+    @staticmethod
+    def supports_config(config: DSNormConfig):
+        type = NormTypeEnum(config.type)
+        if type != NormTypeEnum.RMSNorm:
+            return False
+
+        if len(set([config.residual_dtype, config.input_dtype, config.output_dtype])) != 1:
+            return False
+
+        try:
+            # Only need to check one since the support matrix for the two rms kernels is the same
+            _ = CUDARMSPreNorm(config.channels, config.residual_dtype)
+        except ValueError:
+            return False
+        return True
+
+    def __init__(self, config: DSNormConfig, implementation_config: Dict[str, Any]):
+        super().__init__(config, implementation_config)
+        self._fp_rms = CUDARMSNorm(self._config.channels, self._config.residual_dtype, epsilon=self._config.eps)
+        self._fp_rms_pre = CUDARMSPreNorm(self._config.channels, self._config.residual_dtype, epsilon=self._config.eps)
+
+        # Buffers for both the hidden and residual outputs
+        self._hidden_output = torch.empty((config.max_tokens, config.channels),
+                                          dtype=config.output_dtype,
+                                          device=get_accelerator().current_device())
+        self._residual_output = torch.empty((config.max_tokens, config.channels),
+                                            dtype=config.output_dtype,
+                                            device=get_accelerator().current_device())
+
+    def transform_param(self, param: torch.Tensor) -> InferenceParameter:
+        param = param.to(self._config.input_dtype)
+        return InferenceParameter.initialize(param)
+
+    def forward(self,
+                residual: torch.Tensor,
+                hidden_in: Optional[torch.Tensor],
+                gamma: torch.Tensor,
+                beta: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Since the CUDA FP only supports all data types being the same, we will alias the residual
+        with our output.
+
+        If hidden_in is None, that means we do not need to perform the residual add and will
+        only return the hidden output modified.
+        """
+        assert beta is None, "Beta is not supported for RMSNorm"
+
+        hidden_out = empty_from(self._hidden_output, residual.shape)
+        if hidden_in is None:
+            self._fp_rms(hidden_out, residual, gamma)
+            residual_out = residual
+        else:
+            residual_out = empty_from(self._residual_output, residual.shape)
+            self._fp_rms_pre(residual_out, hidden_out, residual, hidden_in, gamma)
+        return residual_out, hidden_out

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/unembed/__init__.py

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

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/implementations/unembed/ragged_unembed.py

@@ -0,0 +1,120 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Any, Dict, Optional
+
+import torch
+
+from deepspeed.accelerator import get_accelerator
+from ....allocator import empty_from
+from ....inference_utils import DtypeEnum, ActivationType
+from ....kernels.core_ops import CUDAFPLN, BlasLibLinear, CUDARMSNorm, CUDABiasActivation
+from ....kernels.ragged_ops import RaggedLogitsGather
+from ....ragged import RaggedBatchWrapper
+from ...interfaces import DSUnembedBase, DSUnembedRegistry
+from ...configs import DSUnembedConfig
+
+
+@DSUnembedRegistry.register_module
+class DSRaggedUnembed(DSUnembedBase):
+    """
+    Ragged unembedding implementation. This implementation will gather only the last token
+    of each sequence in the ragged inflight batch and calculate the logits only for those rows.
+    """
+
+    @staticmethod
+    def name():
+        return 'ragged_unembed'
+
+    @staticmethod
+    def supports_config(config: DSUnembedConfig):
+
+        if DtypeEnum(config.dtype) not in [DtypeEnum.fp16, DtypeEnum.bf16, DtypeEnum.fp32]:
+            return False
+
+        try:
+            _ = RaggedLogitsGather(config.model_dim, config.dtype)
+        except ValueError:
+            return False
+
+        if config.norm_type == 'rms_norm':
+            try:
+                _ = CUDARMSNorm(config.model_dim, config.dtype)
+            except ValueError:
+                return False
+        elif config.norm_type == 'layer_norm':
+            try:
+                _ = CUDAFPLN(config.model_dim, config.dtype)
+            except ValueError:
+                return False
+
+        return True
+
+    def __init__(self, config: DSUnembedConfig, implementation_config: Dict[str, Any]) -> None:
+        super().__init__(config, implementation_config)
+
+        self._logits_gather = RaggedLogitsGather(config.model_dim, self._config.dtype)
+
+        if self._config.norm_type == 'layer_norm':
+            self._norm = CUDAFPLN(self._config.model_dim, self._config.dtype)
+        elif self._config.norm_type == 'rms_norm':
+            self._norm = CUDARMSNorm(self._config.model_dim, self._config.dtype)
+        else:
+            self._norm = None
+
+        self._linear = BlasLibLinear(self._config.dtype)
+        # Here the activation kernel is being used to apply bias, hence the identity activation type!
+        self._act_fn = CUDABiasActivation(self._config.vocab_size, self._config.dtype, ActivationType.IDENTITY)
+
+        self._intermediate = torch.empty((self._config.max_sequences, self._config.model_dim),
+                                         dtype=self._config.dtype,
+                                         device=get_accelerator().current_device())
+
+        self._output = torch.empty((self._config.max_sequences, self._config.vocab_size),
+                                   dtype=self._config.dtype,
+                                   device=get_accelerator().current_device())
+
+    @property
+    def output(self) -> torch.Tensor:
+        return self._output
+
+    def forward(self,
+                hidden_states: torch.Tensor,
+                vocab_embedding: torch.Tensor,
+                ragged_metadata: RaggedBatchWrapper,
+                bias: Optional[torch.Tensor] = None,
+                gamma: Optional[torch.Tensor] = None,
+                beta: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """
+        Return final model logits.
+
+        Args:
+            hidden_states (torch.Tensor): The hidden states from the model. This is the output of the
+                final layer of the model.
+            vocab_embedding (torch.Tensor): The vocab embedding table.
+            raged_metadata (RaggedBatchWrapper): The ragged batch metadata.
+            gamma (Optional[torch.Tensor]): The gamma tensor for normalization.
+            beta (Optional[torch.Tensor]): The beta tensor for normalization.
+        """
+
+        cut_down_hidden_states = empty_from(self._intermediate,
+                                            (ragged_metadata.current_sequences, self._config.model_dim))
+        self._logits_gather(cut_down_hidden_states, hidden_states, ragged_metadata)
+
+        if self._config.norm_type == 'rms_norm':
+            if gamma is None:
+                raise ValueError('RMS Normalization enabled but gamma not provided.')
+            self._norm(cut_down_hidden_states, cut_down_hidden_states, gamma)
+        elif self._config.norm_type == 'layer_norm':
+            if gamma is None or beta is None:
+                raise ValueError('Normalization enabled but gamma and/or beta not provided.')
+            self._norm(cut_down_hidden_states, cut_down_hidden_states, gamma, beta)
+
+        output = empty_from(self._output, (ragged_metadata.current_sequences, self._config.vocab_size))
+        self._linear(output, cut_down_hidden_states, vocab_embedding)
+        if bias is not None:
+            self._act_fn(output, bias)
+
+        return output

venv/lib/python3.10/site-packages/deepspeed/inference/v2/modules/interfaces/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .attention_base import DSSelfAttentionRegistry, DSSelfAttentionBase
+from .embedding_base import DSEmbeddingRegistry, DSEmbeddingBase
+from .linear_base import DSLinearRegistry, DSLinearBase
+from .moe_base import DSMoERegistry, DSMoEBase
+from .post_norm_base import DSPostNormRegistry, DSPostNormBase
+from .pre_norm_base import DSPreNormRegistry, DSPreNormBase
+from .unembed_base import DSUnembedRegistry, DSUnembedBase