snowflake-ml-python 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

snowflake/ml/model/_packager/model_handlers/catboost.py

@@ -0,0 +1,206 @@
+import os
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, cast, final
+
+import numpy as np
+import pandas as pd
+from typing_extensions import TypeGuard, Unpack
+
+from snowflake.ml._internal import type_utils
+from snowflake.ml.model import custom_model, model_signature, type_hints as model_types
+from snowflake.ml.model._packager.model_env import model_env
+from snowflake.ml.model._packager.model_handlers import _base, _utils as handlers_utils
+from snowflake.ml.model._packager.model_handlers_migrator import base_migrator
+from snowflake.ml.model._packager.model_meta import (
+    model_blob_meta,
+    model_meta as model_meta_api,
+    model_meta_schema,
+)
+from snowflake.ml.model._signatures import numpy_handler, utils as model_signature_utils
+
+if TYPE_CHECKING:
+    import catboost
+
+
+@final
+class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
+    """Handler for CatBoost based model."""
+
+    HANDLER_TYPE = "catboost"
+    HANDLER_VERSION = "2024-03-21"
+    _MIN_SNOWPARK_ML_VERSION = "1.3.1"
+    _HANDLER_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelHandlerMigrator]] = {}
+
+    MODELE_BLOB_FILE_OR_DIR = "model.bin"
+    DEFAULT_TARGET_METHODS = ["predict", "predict_proba"]
+
+    @classmethod
+    def can_handle(cls, model: model_types.SupportedModelType) -> TypeGuard["catboost.CatBoost"]:
+        return (type_utils.LazyType("catboost.CatBoost").isinstance(model)) and any(
+            (hasattr(model, method) and callable(getattr(model, method, None))) for method in cls.DEFAULT_TARGET_METHODS
+        )
+
+    @classmethod
+    def cast_model(
+        cls,
+        model: model_types.SupportedModelType,
+    ) -> "catboost.CatBoost":
+        import catboost
+
+        assert isinstance(model, catboost.CatBoost)
+
+        return model
+
+    @classmethod
+    def save_model(
+        cls,
+        name: str,
+        model: "catboost.CatBoost",
+        model_meta: model_meta_api.ModelMetadata,
+        model_blobs_dir_path: str,
+        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        is_sub_model: Optional[bool] = False,
+        **kwargs: Unpack[model_types.CatBoostModelSaveOptions],
+    ) -> None:
+        import catboost
+
+        assert isinstance(model, catboost.CatBoost)
+
+        if not is_sub_model:
+            target_methods = handlers_utils.get_target_methods(
+                model=model,
+                target_methods=kwargs.pop("target_methods", None),
+                default_target_methods=cls.DEFAULT_TARGET_METHODS,
+            )
+
+            def get_prediction(
+                target_method_name: str, sample_input_data: model_types.SupportedLocalDataType
+            ) -> model_types.SupportedLocalDataType:
+                if not isinstance(sample_input_data, (pd.DataFrame, np.ndarray)):
+                    sample_input_data = model_signature._convert_local_data_to_df(sample_input_data)
+                target_method = getattr(model, target_method_name, None)
+                assert callable(target_method)
+                predictions_df = target_method(sample_input_data)
+                return predictions_df
+
+            model_meta = handlers_utils.validate_signature(
+                model=model,
+                model_meta=model_meta,
+                target_methods=target_methods,
+                sample_input_data=sample_input_data,
+                get_prediction_fn=get_prediction,
+            )
+
+        model_blob_path = os.path.join(model_blobs_dir_path, name)
+        os.makedirs(model_blob_path, exist_ok=True)
+        model_save_path = os.path.join(model_blob_path, cls.MODELE_BLOB_FILE_OR_DIR)
+
+        model.save_model(model_save_path)
+
+        base_meta = model_blob_meta.ModelBlobMeta(
+            name=name,
+            model_type=cls.HANDLER_TYPE,
+            handler_version=cls.HANDLER_VERSION,
+            path=cls.MODELE_BLOB_FILE_OR_DIR,
+            options=model_meta_schema.CatBoostModelBlobOptions({"catboost_estimator_type": model.__class__.__name__}),
+        )
+        model_meta.models[name] = base_meta
+        model_meta.min_snowpark_ml_version = cls._MIN_SNOWPARK_ML_VERSION
+
+        model_meta.env.include_if_absent(
+            [
+                model_env.ModelDependency(requirement="catboost", pip_name="catboost"),
+            ],
+            check_local_version=True,
+        )
+        model_meta.env.cuda_version = kwargs.get("cuda_version", model_env.DEFAULT_CUDA_VERSION)
+
+        return None
+
+    @classmethod
+    def load_model(
+        cls,
+        name: str,
+        model_meta: model_meta_api.ModelMetadata,
+        model_blobs_dir_path: str,
+        **kwargs: Unpack[model_types.ModelLoadOption],
+    ) -> "catboost.CatBoost":
+        import catboost
+
+        model_blob_path = os.path.join(model_blobs_dir_path, name)
+        model_blobs_metadata = model_meta.models
+        model_blob_metadata = model_blobs_metadata[name]
+        model_blob_filename = model_blob_metadata.path
+        model_blob_file_path = os.path.join(model_blob_path, model_blob_filename)
+
+        model_blob_options = cast(model_meta_schema.CatBoostModelBlobOptions, model_blob_metadata.options)
+        if "catboost_estimator_type" not in model_blob_options:
+            raise ValueError("Missing field `catboost_estimator_type` in model blob metadata for type `catboost`")
+
+        catboost_estimator_type = model_blob_options["catboost_estimator_type"]
+        if not hasattr(catboost, catboost_estimator_type):
+            raise ValueError("Type of CatBoost estimator is not supported.")
+
+        assert os.path.isfile(model_blob_file_path)  # saved model is a file
+        model = getattr(catboost, catboost_estimator_type)()
+        model.load_model(model_blob_file_path)
+        assert isinstance(model, getattr(catboost, catboost_estimator_type))
+
+        if kwargs.get("use_gpu", False):
+            assert type(kwargs.get("use_gpu", False)) == bool
+            gpu_params = {"task_type": "GPU"}
+            model.__dict__.update(gpu_params)
+
+        return model
+
+    @classmethod
+    def convert_as_custom_model(
+        cls,
+        raw_model: "catboost.CatBoost",
+        model_meta: model_meta_api.ModelMetadata,
+        **kwargs: Unpack[model_types.ModelLoadOption],
+    ) -> custom_model.CustomModel:
+        import catboost
+
+        from snowflake.ml.model import custom_model
+
+        def _create_custom_model(
+            raw_model: "catboost.CatBoost",
+            model_meta: model_meta_api.ModelMetadata,
+        ) -> Type[custom_model.CustomModel]:
+            def fn_factory(
+                raw_model: "catboost.CatBoost",
+                signature: model_signature.ModelSignature,
+                target_method: str,
+            ) -> Callable[[custom_model.CustomModel, pd.DataFrame], pd.DataFrame]:
+                @custom_model.inference_api
+                def fn(self: custom_model.CustomModel, X: pd.DataFrame) -> pd.DataFrame:
+
+                    res = getattr(raw_model, target_method)(X)
+
+                    if isinstance(res, list) and len(res) > 0 and isinstance(res[0], np.ndarray):
+                        # In case of multi-output estimators, predict_proba(), decision_function(), etc., functions
+                        # return a list of ndarrays. We need to deal them separately
+                        df = numpy_handler.SeqOfNumpyArrayHandler.convert_to_df(res)
+                    else:
+                        df = pd.DataFrame(res)
+
+                    return model_signature_utils.rename_pandas_df(df, signature.outputs)
+
+                return fn
+
+            type_method_dict: Dict[str, Any] = {"_raw_model": raw_model}
+            for target_method_name, sig in model_meta.signatures.items():
+                type_method_dict[target_method_name] = fn_factory(raw_model, sig, target_method_name)
+
+            _CatBoostModel = type(
+                "_CatBoostModel",
+                (custom_model.CustomModel,),
+                type_method_dict,
+            )
+
+            return _CatBoostModel
+
+        _CatBoostModel = _create_custom_model(raw_model, model_meta)
+        catboost_model = _CatBoostModel(custom_model.ModelContext())
+
+        return catboost_model

snowflake/ml/model/_packager/model_handlers/lightgbm.py

@@ -0,0 +1,218 @@
+import os
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Optional,
+    Type,
+    Union,
+    cast,
+    final,
+)
+
+import cloudpickle
+import numpy as np
+import pandas as pd
+from typing_extensions import TypeGuard, Unpack
+
+from snowflake.ml._internal import type_utils
+from snowflake.ml.model import custom_model, model_signature, type_hints as model_types
+from snowflake.ml.model._packager.model_env import model_env
+from snowflake.ml.model._packager.model_handlers import _base, _utils as handlers_utils
+from snowflake.ml.model._packager.model_handlers_migrator import base_migrator
+from snowflake.ml.model._packager.model_meta import (
+    model_blob_meta,
+    model_meta as model_meta_api,
+    model_meta_schema,
+)
+from snowflake.ml.model._signatures import numpy_handler, utils as model_signature_utils
+
+if TYPE_CHECKING:
+    import lightgbm
+
+
+@final
+class LGBMModelHandler(_base.BaseModelHandler[Union["lightgbm.Booster", "lightgbm.LGBMModel"]]):
+    """Handler for LightGBM based model."""
+
+    HANDLER_TYPE = "lightgbm"
+    HANDLER_VERSION = "2024-03-19"
+    _MIN_SNOWPARK_ML_VERSION = "1.3.1"
+    _HANDLER_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelHandlerMigrator]] = {}
+
+    MODELE_BLOB_FILE_OR_DIR = "model.pkl"
+    DEFAULT_TARGET_METHODS = ["predict", "predict_proba"]
+
+    @classmethod
+    def can_handle(
+        cls, model: model_types.SupportedModelType
+    ) -> TypeGuard[Union["lightgbm.Booster", "lightgbm.LGBMModel"]]:
+        return (
+            type_utils.LazyType("lightgbm.Booster").isinstance(model)
+            or type_utils.LazyType("lightgbm.LGBMModel").isinstance(model)
+        ) and any(
+            (hasattr(model, method) and callable(getattr(model, method, None))) for method in cls.DEFAULT_TARGET_METHODS
+        )
+
+    @classmethod
+    def cast_model(
+        cls,
+        model: model_types.SupportedModelType,
+    ) -> Union["lightgbm.Booster", "lightgbm.LGBMModel"]:
+        import lightgbm
+
+        assert isinstance(model, lightgbm.Booster) or isinstance(model, lightgbm.LGBMModel)
+
+        return model
+
+    @classmethod
+    def save_model(
+        cls,
+        name: str,
+        model: Union["lightgbm.Booster", "lightgbm.LGBMModel"],
+        model_meta: model_meta_api.ModelMetadata,
+        model_blobs_dir_path: str,
+        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        is_sub_model: Optional[bool] = False,
+        **kwargs: Unpack[model_types.LGBMModelSaveOptions],
+    ) -> None:
+        import lightgbm
+
+        assert isinstance(model, lightgbm.Booster) or isinstance(model, lightgbm.LGBMModel)
+
+        if not is_sub_model:
+            target_methods = handlers_utils.get_target_methods(
+                model=model,
+                target_methods=kwargs.pop("target_methods", None),
+                default_target_methods=cls.DEFAULT_TARGET_METHODS,
+            )
+
+            def get_prediction(
+                target_method_name: str, sample_input_data: model_types.SupportedLocalDataType
+            ) -> model_types.SupportedLocalDataType:
+                if not isinstance(sample_input_data, (pd.DataFrame, np.ndarray)):
+                    sample_input_data = model_signature._convert_local_data_to_df(sample_input_data)
+                target_method = getattr(model, target_method_name, None)
+                assert callable(target_method)
+                predictions_df = target_method(sample_input_data)
+                return predictions_df
+
+            model_meta = handlers_utils.validate_signature(
+                model=model,
+                model_meta=model_meta,
+                target_methods=target_methods,
+                sample_input_data=sample_input_data,
+                get_prediction_fn=get_prediction,
+            )
+
+        model_blob_path = os.path.join(model_blobs_dir_path, name)
+        os.makedirs(model_blob_path, exist_ok=True)
+
+        model_save_path = os.path.join(model_blob_path, cls.MODELE_BLOB_FILE_OR_DIR)
+        with open(model_save_path, "wb") as f:
+            cloudpickle.dump(model, f)
+
+        base_meta = model_blob_meta.ModelBlobMeta(
+            name=name,
+            model_type=cls.HANDLER_TYPE,
+            handler_version=cls.HANDLER_VERSION,
+            path=cls.MODELE_BLOB_FILE_OR_DIR,
+            options=model_meta_schema.LightGBMModelBlobOptions({"lightgbm_estimator_type": model.__class__.__name__}),
+        )
+        model_meta.models[name] = base_meta
+        model_meta.min_snowpark_ml_version = cls._MIN_SNOWPARK_ML_VERSION
+
+        model_meta.env.include_if_absent(
+            [
+                model_env.ModelDependency(requirement="lightgbm", pip_name="lightgbm"),
+                model_env.ModelDependency(requirement="scikit-learn", pip_name="scikit-learn"),
+            ],
+            check_local_version=True,
+        )
+
+        return None
+
+    @classmethod
+    def load_model(
+        cls,
+        name: str,
+        model_meta: model_meta_api.ModelMetadata,
+        model_blobs_dir_path: str,
+        **kwargs: Unpack[model_types.ModelLoadOption],
+    ) -> Union["lightgbm.Booster", "lightgbm.LGBMModel"]:
+        import lightgbm
+
+        model_blob_path = os.path.join(model_blobs_dir_path, name)
+        model_blobs_metadata = model_meta.models
+        model_blob_metadata = model_blobs_metadata[name]
+        model_blob_filename = model_blob_metadata.path
+        model_blob_file_path = os.path.join(model_blob_path, model_blob_filename)
+
+        model_blob_options = cast(model_meta_schema.LightGBMModelBlobOptions, model_blob_metadata.options)
+        if "lightgbm_estimator_type" not in model_blob_options:
+            raise ValueError("Missing field `lightgbm_estimator_type` in model blob metadata for type `lightgbm`")
+
+        lightgbm_estimator_type = model_blob_options["lightgbm_estimator_type"]
+        if not hasattr(lightgbm, lightgbm_estimator_type):
+            raise ValueError("Type of LightGBM estimator is not supported.")
+
+        assert os.path.isfile(model_blob_file_path)  # saved model is a file
+        with open(model_blob_file_path, "rb") as f:
+            model = cloudpickle.load(f)
+        assert isinstance(model, getattr(lightgbm, lightgbm_estimator_type))
+
+        return model
+
+    @classmethod
+    def convert_as_custom_model(
+        cls,
+        raw_model: Union["lightgbm.Booster", "lightgbm.XGBModel"],
+        model_meta: model_meta_api.ModelMetadata,
+        **kwargs: Unpack[model_types.ModelLoadOption],
+    ) -> custom_model.CustomModel:
+        import lightgbm
+
+        from snowflake.ml.model import custom_model
+
+        def _create_custom_model(
+            raw_model: Union["lightgbm.Booster", "lightgbm.LGBMModel"],
+            model_meta: model_meta_api.ModelMetadata,
+        ) -> Type[custom_model.CustomModel]:
+            def fn_factory(
+                raw_model: Union["lightgbm.Booster", "lightgbm.LGBMModel"],
+                signature: model_signature.ModelSignature,
+                target_method: str,
+            ) -> Callable[[custom_model.CustomModel, pd.DataFrame], pd.DataFrame]:
+                @custom_model.inference_api
+                def fn(self: custom_model.CustomModel, X: pd.DataFrame) -> pd.DataFrame:
+
+                    res = getattr(raw_model, target_method)(X)
+
+                    if isinstance(res, list) and len(res) > 0 and isinstance(res[0], np.ndarray):
+                        # In case of multi-output estimators, predict_proba(), decision_function(), etc., functions
+                        # return a list of ndarrays. We need to deal them separately
+                        df = numpy_handler.SeqOfNumpyArrayHandler.convert_to_df(res)
+                    else:
+                        df = pd.DataFrame(res)
+
+                    return model_signature_utils.rename_pandas_df(df, signature.outputs)
+
+                return fn
+
+            type_method_dict: Dict[str, Any] = {"_raw_model": raw_model}
+            for target_method_name, sig in model_meta.signatures.items():
+                type_method_dict[target_method_name] = fn_factory(raw_model, sig, target_method_name)
+
+            _LightGBMModel = type(
+                "_LightGBMModel",
+                (custom_model.CustomModel,),
+                type_method_dict,
+            )
+
+            return _LightGBMModel
+
+        _LightGBMModel = _create_custom_model(raw_model, model_meta)
+        lightgbm_model = _LightGBMModel(custom_model.ModelContext())
+
+        return lightgbm_model

snowflake/ml/model/_packager/model_handlers/sklearn.py

@@ -47,6 +47,9 @@ class SKLModelHandler(_base.BaseModelHandler[Union["sklearn.base.BaseEstimator",
                 or type_utils.LazyType("sklearn.pipeline.Pipeline").isinstance(model)
             )
             and (not type_utils.LazyType("xgboost.XGBModel").isinstance(model))  # XGBModel is actually a BaseEstimator
+            and (
+                not type_utils.LazyType("lightgbm.LGBMModel").isinstance(model)
+            )  # LGBMModel is actually a BaseEstimator
             and any(
                 (hasattr(model, method) and callable(getattr(model, method, None)))
                 for method in cls.DEFAULT_TARGET_METHODS

snowflake/ml/model/_packager/model_meta/_core_requirements.py

@@ -4,7 +4,7 @@ REQUIREMENTS = [
     "cloudpickle>=2.0.0",
     "numpy>=1.23,<2",
     "packaging>=20.9,<24",
-    "pandas>=1.0.0,<2",
+    "pandas>=1.0.0,<3",
     "pyyaml>=6.0,<7",
     "snowflake-snowpark-python>=1.11.1,<2,!=1.12.0",
     "typing-extensions>=4.1.0,<5"

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -23,6 +23,7 @@ from snowflake.ml.model._packager.model_meta import (
     model_meta_schema,
 )
 from snowflake.ml.model._packager.model_meta_migrator import migrator_plans
+from snowflake.ml.model._packager.model_runtime import model_runtime
 
 MODEL_METADATA_FILE = "model.yaml"
 MODEL_CODE_DIR = "code"
@@ -115,7 +116,6 @@ def create_model_metadata(
         python_version=python_version,
         embed_local_ml_library=embed_local_ml_library,
         legacy_save=legacy_save,
-        relax_version=relax_version,
     )
 
     if embed_local_ml_library:
@@ -156,6 +156,8 @@ def create_model_metadata(
                     cloudpickle.register_pickle_by_value(mod)
                     imported_modules.append(mod)
         yield model_meta
+        if relax_version:
+            model_meta.env.relax_version()
         model_meta.save(model_dir_path)
     finally:
         for mod in imported_modules:
@@ -169,7 +171,6 @@ def _create_env_for_model_metadata(
     python_version: Optional[str] = None,
     embed_local_ml_library: bool = False,
     legacy_save: bool = False,
-    relax_version: bool = False,
 ) -> model_env.ModelEnv:
     env = model_env.ModelEnv()
 
@@ -197,10 +198,6 @@ def _create_env_for_model_metadata(
             ],
             check_local_version=True,
         )
-
-    if relax_version:
-        env.relax_version()
-
     return env
 
 
@@ -237,6 +234,7 @@ class ModelMetadata:
         name: str,
         env: model_env.ModelEnv,
         model_type: model_types.SupportedModelHandlerType,
+        runtimes: Optional[Dict[str, model_runtime.ModelRuntime]] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
         metadata: Optional[Dict[str, str]] = None,
         creation_timestamp: Optional[str] = None,
@@ -262,6 +260,8 @@ class ModelMetadata:
         if models:
             self.models = models
 
+        self._runtimes = runtimes
+
         self.original_metadata_version = original_metadata_version
 
     @property
@@ -273,6 +273,19 @@ class ModelMetadata:
         parsed_min_snowpark_ml_version = version.parse(min_snowpark_ml_version)
         self._min_snowpark_ml_version = max(self._min_snowpark_ml_version, parsed_min_snowpark_ml_version)
 
+    @property
+    def runtimes(self) -> Dict[str, model_runtime.ModelRuntime]:
+        if self._runtimes and "cpu" in self._runtimes:
+            return self._runtimes
+        runtimes = {
+            "cpu": model_runtime.ModelRuntime("cpu", self.env),
+        }
+        if self.env.cuda_version:
+            runtimes.update(
+                {"gpu": model_runtime.ModelRuntime("gpu", self.env, is_gpu=True, server_availability_source="conda")}
+            )
+        return runtimes
+
     def save(self, model_dir_path: str) -> None:
         """Save the model metadata
 
@@ -291,6 +304,10 @@ class ModelMetadata:
             {
                 "creation_timestamp": self.creation_timestamp,
                 "env": self.env.save_as_dict(pathlib.Path(model_dir_path)),
+                "runtimes": {
+                    runtime_name: runtime.save(pathlib.Path(model_dir_path))
+                    for runtime_name, runtime in self.runtimes.items()
+                },
                 "metadata": self.metadata,
                 "model_type": self.model_type,
                 "models": {model_name: blob.to_dict() for model_name, blob in self.models.items()},
@@ -302,11 +319,8 @@ class ModelMetadata:
         )
 
         with open(model_yaml_path, "w", encoding="utf-8") as out:
-            yaml.safe_dump(
-                model_dict,
-                stream=out,
-                default_flow_style=False,
-            )
+            yaml.SafeDumper.ignore_aliases = lambda *args: True  # type: ignore[method-assign]
+            yaml.safe_dump(model_dict, stream=out, default_flow_style=False)
 
     @staticmethod
     def _validate_model_metadata(loaded_meta: Any) -> model_meta_schema.ModelMetadataDict:
@@ -330,6 +344,7 @@ class ModelMetadata:
         return model_meta_schema.ModelMetadataDict(
             creation_timestamp=loaded_meta["creation_timestamp"],
             env=loaded_meta["env"],
+            runtimes=loaded_meta.get("runtimes", None),
             metadata=loaded_meta.get("metadata", None),
             model_type=loaded_meta["model_type"],
             models=loaded_meta["models"],
@@ -363,10 +378,21 @@ class ModelMetadata:
         models = {name: model_blob_meta.ModelBlobMeta(**blob_meta) for name, blob_meta in model_dict["models"].items()}
         env = model_env.ModelEnv()
         env.load_from_dict(pathlib.Path(model_dir_path), model_dict["env"])
+
+        runtimes: Optional[Dict[str, model_runtime.ModelRuntime]]
+        if model_dict.get("runtimes", None):
+            runtimes = {
+                name: model_runtime.ModelRuntime.load(pathlib.Path(model_dir_path), name, env, runtime_dict)
+                for name, runtime_dict in model_dict["runtimes"].items()
+            }
+        else:
+            runtimes = None
+
         return cls(
             name=model_dict["name"],
             model_type=model_dict["model_type"],
             env=env,
+            runtimes=runtimes,
             signatures=signatures,
             metadata=model_dict.get("metadata", None),
             creation_timestamp=model_dict["creation_timestamp"],

snowflake/ml/model/_packager/model_meta/model_meta_schema.py

@@ -1,7 +1,7 @@
 # This files contains schema definition of what will be written into model.yml
 # Changing this file should lead to a change of the schema version.
 
-from typing import Any, Dict, Optional, TypedDict, Union
+from typing import Any, Dict, List, Optional, TypedDict, Union
 
 from typing_extensions import NotRequired, Required
 
@@ -11,6 +11,16 @@ MODEL_METADATA_VERSION = "2023-12-01"
 MODEL_METADATA_MIN_SNOWPARK_ML_VERSION = "1.0.12"
 
 
+class ModelRuntimeDependenciesDict(TypedDict):
+    conda: Required[str]
+    pip: Required[str]
+
+
+class ModelRuntimeDict(TypedDict):
+    imports: Required[List[str]]
+    dependencies: Required[ModelRuntimeDependenciesDict]
+
+
 class ModelEnvDict(TypedDict):
     conda: Required[str]
     pip: Required[str]
@@ -23,11 +33,19 @@ class BaseModelBlobOptions(TypedDict):
     ...
 
 
+class CatBoostModelBlobOptions(BaseModelBlobOptions):
+    catboost_estimator_type: Required[str]
+
+
 class HuggingFacePipelineModelBlobOptions(BaseModelBlobOptions):
     task: Required[str]
     batch_size: Required[int]
 
 
+class LightGBMModelBlobOptions(BaseModelBlobOptions):
+    lightgbm_estimator_type: Required[str]
+
+
 class LLMModelBlobOptions(BaseModelBlobOptions):
     batch_size: Required[int]
 
@@ -61,6 +79,7 @@ class ModelBlobMetadataDict(TypedDict):
 class ModelMetadataDict(TypedDict):
     creation_timestamp: Required[str]
     env: Required[ModelEnvDict]
+    runtimes: NotRequired[Dict[str, ModelRuntimeDict]]
     metadata: NotRequired[Optional[Dict[str, str]]]
     model_type: Required[type_hints.SupportedModelHandlerType]
     models: Required[Dict[str, ModelBlobMetadataDict]]

snowflake/ml/model/_packager/model_meta_migrator/migrator_plans.py

@@ -3,7 +3,9 @@ from typing import Any, Dict, Type
 from snowflake.ml.model._packager.model_meta import model_meta_schema
 from snowflake.ml.model._packager.model_meta_migrator import base_migrator, migrator_v1
 
-MODEL_META_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelMetaMigrator]] = {"1": migrator_v1.MetaMigrator_v1}
+MODEL_META_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelMetaMigrator]] = {
+    "1": migrator_v1.MetaMigrator_v1,
+}
 
 
 def migrate_metadata(loaded_meta: Dict[str, Any]) -> Dict[str, Any]:

snowflake/ml/model/_packager/model_packager.py

@@ -4,7 +4,6 @@ from typing import Dict, List, Optional
 
 from absl import logging
 
-from snowflake.ml._internal import env_utils
 from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
@@ -102,8 +101,8 @@ class ModelPackager:
             if signatures is None:
                 logging.info(f"Model signatures are auto inferred as:\n\n{meta.signatures}")
 
-            self.model = model
-            self.meta = meta
+        self.model = model
+        self.meta = meta
 
     def load(
         self,
@@ -129,8 +128,6 @@ class ModelPackager:
 
         model_meta.load_code_path(self.local_dir_path)
 
-        env_utils.validate_py_runtime_version(self.meta.env.python_version)
-
         handler = model_handler.load_handler(self.meta.model_type)
         if handler is None:
             raise snowml_exceptions.SnowflakeMLException(

snowflake/ml/model/{_model_composer/model_runtime/_runtime_requirements.py → _packager/model_runtime/_snowml_inference_alternative_requirements.py}

@@ -3,7 +3,7 @@ REQUIREMENTS = [
     "anyio>=3.5.0,<4",
     "numpy>=1.23,<2",
     "packaging>=20.9,<24",
-    "pandas>=1.0.0,<2",
+    "pandas>=1.0.0,<3",
     "pyyaml>=6.0,<7",
     "snowflake-snowpark-python>=1.11.1,<2,!=1.12.0",
     "typing-extensions>=4.1.0,<5"