snowflake-ml-python 1.6.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

snowflake/ml/model/_client/service/model_deployment_spec_schema.py

@@ -0,0 +1,31 @@
+from typing import List, TypedDict
+
+from typing_extensions import NotRequired, Required
+
+
+class ModelDict(TypedDict):
+    name: Required[str]
+    version: Required[str]
+
+
+class ImageBuildDict(TypedDict):
+    compute_pool: Required[str]
+    image_repo: Required[str]
+    image_name: NotRequired[str]
+    force_rebuild: Required[bool]
+    external_access_integrations: Required[List[str]]
+
+
+class ServiceDict(TypedDict):
+    name: Required[str]
+    compute_pool: Required[str]
+    ingress_enabled: Required[bool]
+    min_instances: Required[int]
+    max_instances: Required[int]
+    gpu: NotRequired[str]
+
+
+class ModelDeploymentSpecDict(TypedDict):
+    models: Required[List[ModelDict]]
+    image_build: Required[ImageBuildDict]
+    service: Required[ServiceDict]

snowflake/ml/model/_client/sql/model_version.py

@@ -371,6 +371,7 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         returns: List[Tuple[str, spt.DataType, sql_identifier.SqlIdentifier]],
         partition_column: Optional[sql_identifier.SqlIdentifier],
         statement_params: Optional[Dict[str, Any]] = None,
+        is_partitioned: bool = True,
     ) -> dataframe.DataFrame:
         with_statements = []
         if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
@@ -409,12 +410,20 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
 
         sql = textwrap.dedent(
             f"""WITH {','.join(with_statements)}
-                 SELECT *,
-                 FROM {INTERMEDIATE_TABLE_NAME},
-                     TABLE({module_version_alias}!{method_name.identifier()}({args_sql})
-                     OVER (PARTITION BY {partition_by}))"""
+                SELECT *,
+                FROM {INTERMEDIATE_TABLE_NAME},
+                    TABLE({module_version_alias}!{method_name.identifier()}({args_sql}))"""
         )
 
+        if is_partitioned or partition_column is not None:
+            sql = textwrap.dedent(
+                f"""WITH {','.join(with_statements)}
+                    SELECT *,
+                    FROM {INTERMEDIATE_TABLE_NAME},
+                        TABLE({module_version_alias}!{method_name.identifier()}({args_sql})
+                        OVER (PARTITION BY {partition_by}))"""
+            )
+
         output_df = self._session.sql(sql)
 
         # Prepare the output

snowflake/ml/model/_client/sql/service.py

@@ -0,0 +1,129 @@
+import textwrap
+from typing import Any, Dict, List, Optional, Tuple
+
+from snowflake.ml._internal.utils import (
+    identifier,
+    query_result_checker,
+    sql_identifier,
+)
+from snowflake.ml.model._client.sql import _base
+from snowflake.snowpark import dataframe, functions as F, types as spt
+from snowflake.snowpark._internal import utils as snowpark_utils
+
+
+class ServiceSQLClient(_base._BaseSQLClient):
+    def build_model_container(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        compute_pool_name: sql_identifier.SqlIdentifier,
+        image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
+        image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
+        image_repo_name: sql_identifier.SqlIdentifier,
+        gpu: Optional[str],
+        force_rebuild: bool,
+        external_access_integration: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        actual_image_repo_database = image_repo_database_name or self._database_name
+        actual_image_repo_schema = image_repo_schema_name or self._schema_name
+        fq_model_name = self.fully_qualified_object_name(database_name, schema_name, model_name)
+        fq_image_repo_name = "/" + "/".join(
+            [
+                actual_image_repo_database.identifier(),
+                actual_image_repo_schema.identifier(),
+                image_repo_name.identifier(),
+            ]
+        )
+        is_gpu = gpu is not None
+        query_result_checker.SqlResultValidator(
+            self._session,
+            (
+                f"CALL SYSTEM$BUILD_MODEL_CONTAINER('{fq_model_name}', '{version_name}', '{compute_pool_name}',"
+                f" '{fq_image_repo_name}', '{is_gpu}', '{force_rebuild}', '', '{external_access_integration}')"
+            ),
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+    def deploy_model(
+        self,
+        *,
+        stage_path: str,
+        model_deployment_spec_file_rel_path: str,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        query_result_checker.SqlResultValidator(
+            self._session,
+            f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')",
+            statement_params=statement_params,
+        ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+    def invoke_function_method(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        service_name: sql_identifier.SqlIdentifier,
+        method_name: sql_identifier.SqlIdentifier,
+        input_df: dataframe.DataFrame,
+        input_args: List[sql_identifier.SqlIdentifier],
+        returns: List[Tuple[str, spt.DataType, sql_identifier.SqlIdentifier]],
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> dataframe.DataFrame:
+        with_statements = []
+        if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
+            INTERMEDIATE_TABLE_NAME = "SNOWPARK_ML_MODEL_INFERENCE_INPUT"
+            with_statements.append(f"{INTERMEDIATE_TABLE_NAME} AS ({input_df.queries['queries'][0]})")
+        else:
+            actual_database_name = database_name or self._database_name
+            actual_schema_name = schema_name or self._schema_name
+            tmp_table_name = snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE)
+            INTERMEDIATE_TABLE_NAME = identifier.get_schema_level_object_identifier(
+                actual_database_name.identifier(),
+                actual_schema_name.identifier(),
+                tmp_table_name,
+            )
+            input_df.write.save_as_table(
+                table_name=INTERMEDIATE_TABLE_NAME,
+                mode="errorifexists",
+                table_type="temporary",
+                statement_params=statement_params,
+            )
+
+        INTERMEDIATE_OBJ_NAME = "TMP_RESULT"
+
+        with_sql = f"WITH {','.join(with_statements)}" if with_statements else ""
+        args_sql_list = []
+        for input_arg_value in input_args:
+            args_sql_list.append(input_arg_value)
+        args_sql = ", ".join(args_sql_list)
+
+        sql = textwrap.dedent(
+            f"""{with_sql}
+                SELECT *,
+                    {service_name.identifier()}_{method_name.identifier()}({args_sql}) AS {INTERMEDIATE_OBJ_NAME}
+                FROM {INTERMEDIATE_TABLE_NAME}"""
+        )
+
+        output_df = self._session.sql(sql)
+
+        # Prepare the output
+        output_cols = []
+        output_names = []
+
+        for output_name, output_type, output_col_name in returns:
+            output_cols.append(F.col(INTERMEDIATE_OBJ_NAME)[output_name].astype(output_type))
+            output_names.append(output_col_name)
+
+        output_df = output_df.with_columns(
+            col_names=output_names,
+            values=output_cols,
+        ).drop(INTERMEDIATE_OBJ_NAME)
+
+        if statement_params:
+            output_df._statement_params = statement_params  # type: ignore[assignment]
+
+        return output_df

snowflake/ml/model/_model_composer/model_composer.py

@@ -10,6 +10,7 @@ from absl import logging
 from packaging import requirements
 from typing_extensions import deprecated
 
+from snowflake import snowpark
 from snowflake.ml._internal import env as snowml_env, env_utils, file_utils
 from snowflake.ml._internal.lineage import lineage_utils
 from snowflake.ml.data import data_source
@@ -185,4 +186,6 @@ class ModelComposer:
         data_sources = lineage_utils.get_data_sources(model)
         if not data_sources and sample_input_data is not None:
             data_sources = lineage_utils.get_data_sources(sample_input_data)
+            if not data_sources and isinstance(sample_input_data, snowpark.DataFrame):
+                data_sources = [data_source.DataFrameInfo(sample_input_data.queries["queries"][-1])]
         return data_sources

snowflake/ml/model/_model_composer/model_manifest/model_manifest.py

@@ -6,6 +6,7 @@ from typing import List, Optional, cast
 
 import yaml
 
+from snowflake.ml._internal import env_utils
 from snowflake.ml.data import data_source
 from snowflake.ml.model import type_hints
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
@@ -47,7 +48,9 @@ class ModelManifest:
         runtime_to_use = copy.deepcopy(model_meta.runtimes["cpu"])
         runtime_to_use.name = self._DEFAULT_RUNTIME_NAME
         runtime_to_use.imports.append(str(model_rel_path) + "/")
-        runtime_dict = runtime_to_use.save(self.workspace_path)
+        runtime_dict = runtime_to_use.save(
+            self.workspace_path, default_channel_override=env_utils.SNOWFLAKE_CONDA_CHANNEL_URL
+        )
 
         self.function_generator = function_generator.FunctionGenerator(model_dir_rel_path=model_rel_path)
         self.methods: List[model_method.ModelMethod] = []
@@ -137,10 +140,15 @@ class ModelManifest:
                 if isinstance(source, data_source.DatasetInfo):
                     result.append(
                         model_manifest_schema.LineageSourceDict(
-                            # Currently, we only support lineage from Dataset.
                             type=model_manifest_schema.LineageSourceTypes.DATASET.value,
                             entity=source.fully_qualified_name,
                             version=source.version,
                         )
                     )
+                elif isinstance(source, data_source.DataFrameInfo):
+                    result.append(
+                        model_manifest_schema.LineageSourceDict(
+                            type=model_manifest_schema.LineageSourceTypes.QUERY.value, entity=source.sql
+                        )
+                    )
         return result

snowflake/ml/model/_model_composer/model_manifest/model_manifest_schema.py

@@ -57,12 +57,14 @@ class ModelFunctionInfo(TypedDict):
         target_method: actual target method name to be called.
         target_method_function_type: target method function type (FUNCTION or TABLE_FUNCTION).
         signature: The signature of the model method.
+        is_partitioned: Whether the function is partitioned.
     """
 
     name: Required[str]
     target_method: Required[str]
     target_method_function_type: Required[str]
     signature: Required[model_signature.ModelSignature]
+    is_partitioned: Required[bool]
 
 
 class ModelFunctionInfoDict(TypedDict):
@@ -78,6 +80,7 @@ class SnowparkMLDataDict(TypedDict):
 
 class LineageSourceTypes(enum.Enum):
     DATASET = "DATASET"
+    QUERY = "QUERY"
 
 
 class LineageSourceDict(TypedDict):

snowflake/ml/model/_packager/model_env/model_env.py

@@ -363,9 +363,14 @@ class ModelEnv:
         self.cuda_version = env_dict.get("cuda_version", None)
         self.snowpark_ml_version = env_dict["snowpark_ml_version"]
 
-    def save_as_dict(self, base_dir: pathlib.Path) -> model_meta_schema.ModelEnvDict:
+    def save_as_dict(
+        self, base_dir: pathlib.Path, default_channel_override: str = env_utils.SNOWFLAKE_CONDA_CHANNEL_URL
+    ) -> model_meta_schema.ModelEnvDict:
         env_utils.save_conda_env_file(
-            pathlib.Path(base_dir / self.conda_env_rel_path), self._conda_dependencies, self.python_version
+            pathlib.Path(base_dir / self.conda_env_rel_path),
+            self._conda_dependencies,
+            self.python_version,
+            default_channel_override=default_channel_override,
         )
         env_utils.save_requirements_file(
             pathlib.Path(base_dir / self.pip_requirements_rel_path), self._pip_requirements

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

@@ -1,7 +1,8 @@
+import os
 from abc import abstractmethod
-from enum import Enum
 from typing import Dict, Generic, Optional, Protocol, Type, final
 
+import pandas as pd
 from typing_extensions import TypeGuard, Unpack
 
 from snowflake.ml.model import custom_model, type_hints as model_types
@@ -9,15 +10,6 @@ from snowflake.ml.model._packager.model_handlers_migrator import base_migrator
 from snowflake.ml.model._packager.model_meta import model_meta
 
 
-class ModelObjective(Enum):
-    # This is not getting stored anywhere as metadata yet so it should be fine to slowly extend it for better coverage
-    UNKNOWN = "unknown"
-    BINARY_CLASSIFICATION = "binary_classification"
-    MULTI_CLASSIFICATION = "multi_classification"
-    REGRESSION = "regression"
-    RANKING = "ranking"
-
-
 class _BaseModelHandlerProtocol(Protocol[model_types._ModelType]):
     HANDLER_TYPE: model_types.SupportedModelHandlerType
     HANDLER_VERSION: str
@@ -106,6 +98,7 @@ class _BaseModelHandlerProtocol(Protocol[model_types._ModelType]):
         cls,
         raw_model: model_types._ModelType,
         model_meta: model_meta.ModelMetadata,
+        background_data: Optional[pd.DataFrame] = None,
         **kwargs: Unpack[model_types.BaseModelLoadOption],
     ) -> custom_model.CustomModel:
         """Create a custom model class wrap for unified interface when being deployed. The predict method will be
@@ -114,6 +107,7 @@ class _BaseModelHandlerProtocol(Protocol[model_types._ModelType]):
         Args:
             raw_model: original model object,
             model_meta: The model metadata.
+            background_data: The background data used for the model explanations.
             kwargs: Options when converting the model.
 
         Raises:
@@ -131,7 +125,8 @@ class BaseModelHandler(Generic[model_types._ModelType], _BaseModelHandlerProtoco
     _MIN_SNOWPARK_ML_VERSION: The minimal version of Snowpark ML library to use the current handler.
     _HANDLER_MIGRATOR_PLANS: Dict holding handler migrator plans.
 
-    MODELE_BLOB_FILE_OR_DIR: Relative path of the model blob file in the model subdir. Default to "model.pkl".
+    MODEL_BLOB_FILE_OR_DIR: Relative path of the model blob file in the model subdir. Default to "model.pkl".
+    BG_DATA_FILE_SUFFIX: Suffix of the background data file. Default to "_background_data.pqt".
     MODEL_ARTIFACTS_DIR: Relative path of the model artifacts dir in the model subdir. Default to "artifacts"
     DEFAULT_TARGET_METHODS: Default target methods to be logged if not specified in this kind of model. Default to
         ["predict"]
@@ -139,8 +134,10 @@ class BaseModelHandler(Generic[model_types._ModelType], _BaseModelHandlerProtoco
         inputting sample data or model signature. Default to False.
     """
 
-    MODELE_BLOB_FILE_OR_DIR = "model.pkl"
+    MODEL_BLOB_FILE_OR_DIR = "model.pkl"
+    BG_DATA_FILE_SUFFIX = "_background_data.pqt"
     MODEL_ARTIFACTS_DIR = "artifacts"
+    EXPLAIN_ARTIFACTS_DIR = "explain_artifacts"
     DEFAULT_TARGET_METHODS = ["predict"]
     IS_AUTO_SIGNATURE = False
 
@@ -169,3 +166,23 @@ class BaseModelHandler(Generic[model_types._ModelType], _BaseModelHandlerProtoco
                 model_meta=model_meta,
                 model_blobs_dir_path=model_blobs_dir_path,
             )
+
+    @classmethod
+    @final
+    def load_background_data(cls, name: str, model_blobs_dir_path: str) -> Optional[pd.DataFrame]:
+        """Load the model into memory.
+
+        Args:
+            name: Name of the model.
+            model_blobs_dir_path: Directory path to the whole model.
+
+        Returns:
+            Optional[pd.DataFrame], background data as pandas DataFrame, if exists.
+        """
+        data_blob_path = os.path.join(model_blobs_dir_path, cls.EXPLAIN_ARTIFACTS_DIR, name + cls.BG_DATA_FILE_SUFFIX)
+        if not os.path.exists(model_blobs_dir_path) or not os.path.isfile(data_blob_path):
+            return None
+        with open(data_blob_path, "rb") as f:
+            background_data = pd.read_parquet(f)
+
+        return background_data

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

@@ -30,24 +30,24 @@ class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
     _MIN_SNOWPARK_ML_VERSION = "1.3.1"
     _HANDLER_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelHandlerMigrator]] = {}
 
-    MODELE_BLOB_FILE_OR_DIR = "model.bin"
+    MODEL_BLOB_FILE_OR_DIR = "model.bin"
     DEFAULT_TARGET_METHODS = ["predict", "predict_proba"]
 
     @classmethod
-    def get_model_objective(cls, model: "catboost.CatBoost") -> _base.ModelObjective:
+    def get_model_objective(cls, model: "catboost.CatBoost") -> model_meta_schema.ModelObjective:
         import catboost
 
         if isinstance(model, catboost.CatBoostClassifier):
             num_classes = handlers_utils.get_num_classes_if_exists(model)
             if num_classes == 2:
-                return _base.ModelObjective.BINARY_CLASSIFICATION
-            return _base.ModelObjective.MULTI_CLASSIFICATION
+                return model_meta_schema.ModelObjective.BINARY_CLASSIFICATION
+            return model_meta_schema.ModelObjective.MULTI_CLASSIFICATION
         if isinstance(model, catboost.CatBoostRanker):
-            return _base.ModelObjective.RANKING
+            return model_meta_schema.ModelObjective.RANKING
         if isinstance(model, catboost.CatBoostRegressor):
-            return _base.ModelObjective.REGRESSION
+            return model_meta_schema.ModelObjective.REGRESSION
         # TODO: Find out model type from the generic Catboost Model
-        return _base.ModelObjective.UNKNOWN
+        return model_meta_schema.ModelObjective.UNKNOWN
 
     @classmethod
     def can_handle(cls, model: model_types.SupportedModelType) -> TypeGuard["catboost.CatBoost"]:
@@ -105,9 +105,11 @@ class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
                 sample_input_data=sample_input_data,
                 get_prediction_fn=get_prediction,
             )
-            if kwargs.get("enable_explainability", False):
+            model_objective = cls.get_model_objective(model)
+            model_meta.model_objective = model_objective
+            if kwargs.get("enable_explainability", True):
                 output_type = model_signature.DataType.DOUBLE
-                if cls.get_model_objective(model) == _base.ModelObjective.MULTI_CLASSIFICATION:
+                if model_objective == model_meta_schema.ModelObjective.MULTI_CLASSIFICATION:
                     output_type = model_signature.DataType.STRING
                 model_meta = handlers_utils.add_explain_method_signature(
                     model_meta=model_meta,
@@ -115,10 +117,13 @@ class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
                     target_method="predict",
                     output_return_type=output_type,
                 )
+                model_meta.function_properties = {
+                    "explain": {model_meta_schema.FunctionProperties.PARTITIONED.value: False}
+                }
 
         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_path = os.path.join(model_blob_path, cls.MODEL_BLOB_FILE_OR_DIR)
 
         model.save_model(model_save_path)
 
@@ -126,7 +131,7 @@ class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
             name=name,
             model_type=cls.HANDLER_TYPE,
             handler_version=cls.HANDLER_VERSION,
-            path=cls.MODELE_BLOB_FILE_OR_DIR,
+            path=cls.MODEL_BLOB_FILE_OR_DIR,
             options=model_meta_schema.CatBoostModelBlobOptions({"catboost_estimator_type": model.__class__.__name__}),
         )
         model_meta.models[name] = base_meta
@@ -138,11 +143,12 @@ class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
             ],
             check_local_version=True,
         )
-        if kwargs.get("enable_explainability", False):
+        if kwargs.get("enable_explainability", True):
             model_meta.env.include_if_absent(
                 [model_env.ModelDependency(requirement="shap", pip_name="shap")],
                 check_local_version=True,
             )
+            model_meta.explain_algorithm = model_meta_schema.ModelExplainAlgorithm.SHAP
         model_meta.env.cuda_version = kwargs.get("cuda_version", model_env.DEFAULT_CUDA_VERSION)
 
         return None
@@ -188,6 +194,7 @@ class CatBoostModelHandler(_base.BaseModelHandler["catboost.CatBoost"]):
         cls,
         raw_model: "catboost.CatBoost",
         model_meta: model_meta_api.ModelMetadata,
+        background_data: Optional[pd.DataFrame] = None,
         **kwargs: Unpack[model_types.CatBoostModelLoadOptions],
     ) -> custom_model.CustomModel:
         import catboost

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

@@ -51,6 +51,9 @@ class CustomModelHandler(_base.BaseModelHandler["custom_model.CustomModel"]):
         **kwargs: Unpack[model_types.CustomModelSaveOption],
     ) -> None:
         assert isinstance(model, custom_model.CustomModel)
+        enable_explainability = kwargs.get("enable_explainability", False)
+        if enable_explainability:
+            raise NotImplementedError("Explainability is not supported for custom model.")
 
         def get_prediction(
             target_method_name: str, sample_input_data: model_types.SupportedLocalDataType
@@ -108,13 +111,13 @@ class CustomModelHandler(_base.BaseModelHandler["custom_model.CustomModel"]):
         # Make sure that the module where the model is defined get pickled by value as well.
         cloudpickle.register_pickle_by_value(sys.modules[model.__module__])
         pickled_obj = (model.__class__, model.context)
-        with open(os.path.join(model_blob_path, cls.MODELE_BLOB_FILE_OR_DIR), "wb") as f:
+        with open(os.path.join(model_blob_path, cls.MODEL_BLOB_FILE_OR_DIR), "wb") as f:
             cloudpickle.dump(pickled_obj, f)
         # model meta will be saved by the context manager
         model_meta.models[name] = model_blob_meta.ModelBlobMeta(
             name=name,
             model_type=cls.HANDLER_TYPE,
-            path=cls.MODELE_BLOB_FILE_OR_DIR,
+            path=cls.MODEL_BLOB_FILE_OR_DIR,
             handler_version=cls.HANDLER_VERSION,
             function_properties=model_meta.function_properties,
             artifacts={
@@ -183,6 +186,7 @@ class CustomModelHandler(_base.BaseModelHandler["custom_model.CustomModel"]):
         cls,
         raw_model: custom_model.CustomModel,
         model_meta: model_meta_api.ModelMetadata,
+        background_data: Optional[pd.DataFrame] = None,
         **kwargs: Unpack[model_types.CustomModelLoadOption],
     ) -> custom_model.CustomModel:
         return raw_model

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

@@ -89,7 +89,7 @@ class HuggingFacePipelineHandler(
     _MIN_SNOWPARK_ML_VERSION = "1.0.12"
     _HANDLER_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelHandlerMigrator]] = {}
 
-    MODELE_BLOB_FILE_OR_DIR = "model"
+    MODEL_BLOB_FILE_OR_DIR = "model"
     ADDITIONAL_CONFIG_FILE = "pipeline_config.pt"
     DEFAULT_TARGET_METHODS = ["__call__"]
     IS_AUTO_SIGNATURE = True
@@ -133,6 +133,9 @@ class HuggingFacePipelineHandler(
         is_sub_model: Optional[bool] = False,
         **kwargs: Unpack[model_types.HuggingFaceSaveOptions],
     ) -> None:
+        enable_explainability = kwargs.get("enable_explainability", False)
+        if enable_explainability:
+            raise NotImplementedError("Explainability is not supported for huggingface model.")
         if type_utils.LazyType("transformers.Pipeline").isinstance(model):
             task = model.task  # type:ignore[attr-defined]
             framework = model.framework  # type:ignore[attr-defined]
@@ -193,7 +196,7 @@ class HuggingFacePipelineHandler(
 
         if type_utils.LazyType("transformers.Pipeline").isinstance(model):
             model.save_pretrained(  # type:ignore[attr-defined]
-                os.path.join(model_blob_path, cls.MODELE_BLOB_FILE_OR_DIR)
+                os.path.join(model_blob_path, cls.MODEL_BLOB_FILE_OR_DIR)
             )
             pipeline_params = {
                 "_batch_size": model._batch_size,  # type:ignore[attr-defined]
@@ -205,7 +208,7 @@ class HuggingFacePipelineHandler(
             with open(
                 os.path.join(
                     model_blob_path,
-                    cls.MODELE_BLOB_FILE_OR_DIR,
+                    cls.MODEL_BLOB_FILE_OR_DIR,
                     cls.ADDITIONAL_CONFIG_FILE,
                 ),
                 "wb",
@@ -213,7 +216,7 @@ class HuggingFacePipelineHandler(
                 cloudpickle.dump(pipeline_params, f)
         else:
             with open(
-                os.path.join(model_blob_path, cls.MODELE_BLOB_FILE_OR_DIR),
+                os.path.join(model_blob_path, cls.MODEL_BLOB_FILE_OR_DIR),
                 "wb",
             ) as f:
                 cloudpickle.dump(model, f)
@@ -222,7 +225,7 @@ class HuggingFacePipelineHandler(
             name=name,
             model_type=cls.HANDLER_TYPE,
             handler_version=cls.HANDLER_VERSION,
-            path=cls.MODELE_BLOB_FILE_OR_DIR,
+            path=cls.MODEL_BLOB_FILE_OR_DIR,
             options=model_meta_schema.HuggingFacePipelineModelBlobOptions(
                 {
                     "task": task,
@@ -329,6 +332,7 @@ class HuggingFacePipelineHandler(
         cls,
         raw_model: Union[huggingface_pipeline.HuggingFacePipelineModel, "transformers.Pipeline"],
         model_meta: model_meta_api.ModelMetadata,
+        background_data: Optional[pd.DataFrame] = None,
         **kwargs: Unpack[model_types.HuggingFaceLoadOptions],
     ) -> custom_model.CustomModel:
         import transformers