add fd plugins && rm model_classed

Author: gzy19990617

fastdeploy/__init__.py

@@ -22,11 +22,10 @@
 os.environ["GLOG_minloglevel"] = "2"
 # suppress log from aistudio
 os.environ["AISTUDIO_LOG"] = "critical"
+import typing
+
 from fastdeploy.engine.sampling_params import SamplingParams
 from fastdeploy.entrypoints.llm import LLM
-from fastdeploy.utils import version
-
-__all__ = ["LLM", "SamplingParams", "version"]
 
 try:
     import use_triton_in_paddle
@@ -86,3 +85,30 @@ def _patch_fastsafetensors():
 
 
 _patch_fastsafetensors()
+
+
+MODULE_ATTRS = {
+    "ModelRegistry": ".model_executor.models.model_base:ModelRegistry",
+}
+
+
+if typing.TYPE_CHECKING:
+    from fastdeploy.model_executor.models.model_base import ModelRegistry
+else:
+
+    def __getattr__(name: str) -> typing.Any:
+        from importlib import import_module
+
+        if name in MODULE_ATTRS:
+            module_name, attr_name = MODULE_ATTRS[name].split(":")
+            module = import_module(module_name, __package__)
+            return getattr(module, attr_name)
+        else:
+            raise AttributeError(f"module {__package__} has no attribute {name}")
+
+
+__all__ = [
+    "LLM",
+    "SamplingParams",
+    "ModelRegistry",
+]

fastdeploy/envs.py

@@ -80,6 +80,8 @@
     "EXPORTER_OTLP_HEADERS": lambda: os.getenv("EXPORTER_OTLP_HEADERS"),
     # enable kv cache block scheduler v1 (no need for kv_cache_ratio)
     "ENABLE_V1_KVCACHE_SCHEDULER": lambda: int(os.getenv("ENABLE_V1_KVCACHE_SCHEDULER", "0")),
+    # Whether to use PLUGINS.
+    "FD_PLUGINS": lambda: None if "FD_PLUGINS" not in os.environ else os.environ["FD_PLUGINS"].split(","),
 }
 
 

fastdeploy/model_executor/model_loader/default_loader.py

@@ -24,7 +24,6 @@
     measure_time,
 )
 from fastdeploy.model_executor.model_loader.base_loader import BaseModelLoader
-from fastdeploy.model_executor.model_loader.utils import get_pretrain_cls
 from fastdeploy.model_executor.models.model_base import ModelRegistry
 from fastdeploy.platforms import current_platform
 
@@ -52,7 +51,7 @@ def clean_memory_fragments(self, state_dict: dict) -> None:
 
     @measure_time
     def load_weights(self, model, fd_config: FDConfig, architectures: str) -> None:
-        model_class = get_pretrain_cls(architectures)
+        model_class = ModelRegistry.get_pretrain_cls(architectures)
         state_dict = load_composite_checkpoint(
             fd_config.model_config.model,
             model_class,

fastdeploy/model_executor/model_loader/utils.py

@@ -19,6 +19,8 @@
 import os
 from pathlib import Path
 
+from paddleformers.transformers import PretrainedModel
+
 from .model_base import ModelForCasualLM, ModelRegistry
 
 
@@ -44,7 +46,14 @@ def auto_models_registry(dir_path, register_path="fastdeploy.model_executor.mode
             for attr_name in dir(module):
                 attr = getattr(module, attr_name)
                 if inspect.isclass(attr) and issubclass(attr, ModelForCasualLM) and attr is not ModelForCasualLM:
-                    ModelRegistry.register(attr)
+                    ModelRegistry.register_model_class(attr)
+                if (
+                    inspect.isclass(attr)
+                    and issubclass(attr, PretrainedModel)
+                    and attr is not PretrainedModel
+                    and hasattr(attr, "arch_name")
+                ):
+                    ModelRegistry.register_pretrained_model(attr)
         except ImportError:
             raise ImportError(f"{module_file=} import error")
 

fastdeploy/model_executor/models/__init__.py

@@ -673,6 +673,10 @@ def _init_weight(self, layer):
         """
         return None
 
+    @classmethod
+    def arch_name(self):
+        return "DeepseekV3ForCausalLM"
+
     @classmethod
     def _get_tensor_parallel_mappings(cls, config, is_split=True):
 

fastdeploy/model_executor/models/deepseek_v3.py

@@ -473,6 +473,10 @@ def _init_weight(self, layer):
         """
         return None
 
+    @classmethod
+    def arch_name(self):
+        return "Ernie4_5_MoeForCausalLM"
+
     weight_infos = [
         WeightMeta(
             f".layers.{{{layerid.LAYER_ID}}}.self_attn.qkv_proj.weight",
@@ -594,3 +598,16 @@ def get_tensor_parallel_split_mappings(num_layers, moe_num_experts, moe_layer_st
             config.prefix_name,
         )
         return mappings
+
+
+class Ernie4_5_DensePretrainedModel(Ernie4_5_PretrainedModel):
+    """
+    Ernie4_5_DensePretrainedModel
+    """
+
+    @classmethod
+    def arch_name(self):
+        """
+        Model Architecture Name
+        """
+        return "Ernie4_5_ForCausalLM"

fastdeploy/model_executor/models/ernie4_5_moe.py

@@ -46,6 +46,10 @@ def _init_weight(self, layer):
         """
         return None
 
+    @classmethod
+    def arch_name(self):
+        return "Ernie4_5_MTPForCausalLM"
+
     @classmethod
     def _get_tensor_parallel_mappings(cls, config, is_split=True):
         """

fastdeploy/model_executor/models/ernie4_5_mtp.py

@@ -624,6 +624,10 @@ def _init_weight(self, layer):
         """
         return None
 
+    @classmethod
+    def arch_name(self):
+        return "Ernie4_5_VLMoeForConditionalGeneration"
+
     from fastdeploy.model_executor.models.tp_utils import TensorSplitMode as tsm
     from fastdeploy.model_executor.models.utils import LayerIdPlaceholder as layerid
     from fastdeploy.model_executor.models.utils import WeightMeta

fastdeploy/model_executor/models/ernie4_5_vl/ernie4_5_vl_moe.py

@@ -20,6 +20,7 @@
 import numpy as np
 import paddle
 from paddle import nn
+from paddleformers.transformers import PretrainedModel
 
 
 class ModelRegistry:
@@ -28,21 +29,52 @@ class ModelRegistry:
     """
 
     _registry = {}
+    _model_classes = {}
 
     @classmethod
-    def register(cls, model_class):
+    def register_model_class(cls, model_class):
         """register model class"""
         if issubclass(model_class, ModelForCasualLM) and model_class is not ModelForCasualLM:
+            # print(model_class.name())
             cls._registry[model_class.name()] = model_class
         return model_class
 
+    @classmethod
+    def register_pretrained_model(cls, pretrained_model):
+        """register pretrained model class"""
+        if (
+            issubclass(pretrained_model, PretrainedModel)
+            and pretrained_model is not PretrainedModel
+            and hasattr(pretrained_model, "arch_name")
+        ):
+            # print(pretrained_model.arch_name())
+            cls._model_classes[pretrained_model.arch_name()] = pretrained_model
+
+        return pretrained_model
+
+    @classmethod
+    def register(cls, model_class, pretrained_model):
+        """register model class and pretrained model class"""
+        cls.register_model_class(model_class)
+        cls.register_pretrained_model(pretrained_model)
+
+    @classmethod
+    def get_pretrain_cls(cls, architectures: str):
+        """get_pretrain_cls"""
+        return cls._model_classes[architectures]
+
     @classmethod
     def get_class(cls, name):
         """get model class"""
         if name not in cls._registry:
             raise ValueError(f"Model '{name}' is not registered!")
         return cls._registry[name]
 
+    @classmethod
+    def get_supported_archs(cls):
+        assert len(cls._registry) == len(cls._registry), "model class / pretrained model registry num is not same"
+        return [key for key in cls._registry.keys()]
+
 
 class ModelForCasualLM(nn.Layer, ABC):
     """