oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.10rc0__py3-none-any.whl

ads/model/serde/model_serializer.py

@@ -0,0 +1,1184 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+import cloudpickle
+import numpy as np
+import pandas as pd
+from ads.model.serde.common import Serializer, Deserializer
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+from ads.common import logger
+from pandas.api.types import is_numeric_dtype, is_string_dtype
+from typing import Any, Dict, List, Optional, Tuple, Union
+from joblib import dump
+
+
+MODEL_SERIALIZATION_TYPE_ONNX = "onnx"
+MODEL_SERIALIZATION_TYPE_CLOUDPICKLE = "cloudpickle"
+MODEL_SERIALIZATION_TYPE_TORHCSCRIPT = "torchscript"
+MODEL_SERIALIZATION_TYPE_TORCH = "torch"
+MODEL_SERIALIZATION_TYPE_TORCH_ONNX = "torch_onnx"
+MODEL_SERIALIZATION_TYPE_TF = "tf"
+MODEL_SERIALIZATION_TYPE_TF_ONNX = "tf_onnx"
+MODEL_SERIALIZATION_TYPE_JOBLIB = "joblib"
+MODEL_SERIALIZATION_TYPE_SKLEARN_ONNX = "sklearn_onnx"
+MODEL_SERIALIZATION_TYPE_LIGHTGBM = "lightgbm"
+MODEL_SERIALIZATION_TYPE_LIGHTGBM_ONNX = "lightgbm_onnx"
+MODEL_SERIALIZATION_TYPE_XGBOOST = "xgboost"
+MODEL_SERIALIZATION_TYPE_XGBOOST_UBJ = "xgboost_ubj"
+MODEL_SERIALIZATION_TYPE_XGBOOST_TXT = "xgboost_txt"
+MODEL_SERIALIZATION_TYPE_XGBOOST_ONNX = "xgboost_onnx"
+MODEL_SERIALIZATION_TYPE_SPARK = "spark"
+MODEL_SERIALIZATION_TYPE_HUGGINGFACE = "huggingface"
+
+
+SUPPORTED_MODEL_SERIALIZERS = [
+    MODEL_SERIALIZATION_TYPE_ONNX,
+    MODEL_SERIALIZATION_TYPE_CLOUDPICKLE,
+    MODEL_SERIALIZATION_TYPE_TORHCSCRIPT,
+    MODEL_SERIALIZATION_TYPE_TORCH,
+    MODEL_SERIALIZATION_TYPE_TORCH_ONNX,
+    MODEL_SERIALIZATION_TYPE_TF,
+    MODEL_SERIALIZATION_TYPE_TF_ONNX,
+    MODEL_SERIALIZATION_TYPE_JOBLIB,
+    MODEL_SERIALIZATION_TYPE_SKLEARN_ONNX,
+    MODEL_SERIALIZATION_TYPE_LIGHTGBM,
+    MODEL_SERIALIZATION_TYPE_LIGHTGBM_ONNX,
+    MODEL_SERIALIZATION_TYPE_XGBOOST,
+    MODEL_SERIALIZATION_TYPE_XGBOOST_ONNX,
+    MODEL_SERIALIZATION_TYPE_SPARK,
+    MODEL_SERIALIZATION_TYPE_HUGGINGFACE,
+]
+
+
+class ModelSerializerType:
+    CLOUDPICKLE = MODEL_SERIALIZATION_TYPE_CLOUDPICKLE
+    ONNX = MODEL_SERIALIZATION_TYPE_ONNX
+
+
+class PyTorchModelSerializerType:
+    TORCH = MODEL_SERIALIZATION_TYPE_TORCH
+    TORCHSCRIPT = MODEL_SERIALIZATION_TYPE_TORHCSCRIPT
+    ONNX = MODEL_SERIALIZATION_TYPE_TORCH_ONNX
+
+
+class TensorflowModelSerializerType:
+    TENSORFLOW = MODEL_SERIALIZATION_TYPE_TF
+    ONNX = MODEL_SERIALIZATION_TYPE_TF_ONNX
+
+
+class LightGBMModelSerializerType:
+    LIGHTGBM = MODEL_SERIALIZATION_TYPE_LIGHTGBM
+    ONNX = MODEL_SERIALIZATION_TYPE_LIGHTGBM_ONNX
+
+
+class SklearnModelSerializerType:
+    JOBLIB = MODEL_SERIALIZATION_TYPE_JOBLIB
+    CLOUDPICKLE = MODEL_SERIALIZATION_TYPE_CLOUDPICKLE
+    ONNX = MODEL_SERIALIZATION_TYPE_SKLEARN_ONNX
+
+
+class XgboostModelSerializerType:
+    XGBOOST = MODEL_SERIALIZATION_TYPE_XGBOOST
+    ONNX = MODEL_SERIALIZATION_TYPE_XGBOOST_ONNX
+
+
+class SparkModelSerializerType:
+    SPARK = MODEL_SERIALIZATION_TYPE_SPARK
+
+
+class HuggingFaceSerializerType:
+    HUGGINGFACE = MODEL_SERIALIZATION_TYPE_HUGGINGFACE
+
+
+class ModelSerializer(Serializer):
+    """Base class for creation of new model serializers."""
+
+    def __init__(self, model_file_suffix):
+        super().__init__()
+        self.model_file_suffix = model_file_suffix
+
+
+class ModelDeserializer(Deserializer):
+    """Base class for creation of new model deserializers."""
+
+    def deserialize(self, **kwargs):
+        raise NotImplementedError
+
+
+class CloudPickleModelSerializer(ModelSerializer):
+    """Uses `Cloudpickle` to save model."""
+
+    def __init__(self, model_file_suffix="pkl"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        """Uses `cloudpickle.dump` to save model. See https://docs.python.org/3/library/pickle.html#pickle.dump for more details.
+
+        Args:
+            estimator: The model to be saved.
+            model_path: The file object or path of the model in which it is to be stored.
+            kwargs:
+                model_save: (dict, optional).
+                    The dictionary where contains the availiable options to be passed to `cloudpickle.dump`.
+        """
+        cloudpickle_kwargs = kwargs.pop("model_save", {})
+        with open(model_path, "wb") as f:
+            cloudpickle.dump(estimator, f, **cloudpickle_kwargs)
+
+
+class JobLibModelSerializer(ModelSerializer):
+    """Uses `Joblib` to save model."""
+
+    def __init__(self, model_file_suffix="joblib"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        """Uses `joblib.dump` to save model. See https://joblib.readthedocs.io/en/latest/generated/joblib.dump.html for more details.
+
+        Args:
+            estimator: The model to be saved.
+            model_path: The file object or path of the model in which it is to be stored.
+            kwargs:
+                model_save: (dict, optional).
+                    The dictionary where contains the availiable options to be passed to `joblib.dump`.
+        """
+        joblib_kwargs = kwargs.pop("model_save", {})
+        dump(estimator, model_path, **joblib_kwargs)
+
+
+class SparkModelSerializer(ModelSerializer):
+    """Save Spark Model."""
+
+    def __init__(self, model_file_suffix=""):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        estimator.write().overwrite().save(model_path)
+
+
+class PyTorchModelSerializer(ModelSerializer):
+    """Save PyTorch Model using torch.save(). See https://pytorch.org/docs/stable/generated/torch.save.html for more details."""
+
+    def __init__(self, model_file_suffix="pt"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    @runtime_dependency(module="torch", install_from=OptionalDependency.PYTORCH)
+    def serialize(self, estimator, model_path, **kwarg):
+        torch.save(estimator.state_dict(), model_path)
+
+
+class TorchScriptModelSerializer(ModelSerializer):
+    """Save PyTorch Model using torchscript. See https://pytorch.org/tutorials/beginner/saving_loading_models.html#export-load-model-in-torchscript-format for more details."""
+
+    def __init__(self, model_file_suffix="pt"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    @runtime_dependency(module="torch", install_from=OptionalDependency.PYTORCH)
+    def serialize(self, estimator, model_path, **kwargs):
+        compiled_model = torch.jit.script(estimator)
+        torch.jit.save(compiled_model, model_path)
+
+
+class LightGBMModelSerializer(ModelSerializer):
+    """Save LightGBM Model through save_model into txt."""
+
+    def __init__(self, model_file_suffix="txt"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        estimator.save_model(model_path)
+
+
+class XgboostJsonModelSerializer(ModelSerializer):
+    """Save Xgboost Model through xgboost.save_model into JSON."""
+
+    def __init__(self, model_file_suffix="json"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        """Save Xgboost Model through xgboost.save_model .See
+        https://xgboost.readthedocs.io/en/stable/python/python_api.html#xgboost.Booster.save_model
+        for more details.
+
+        Args:
+            estimator: The model to be saved.
+            model_path: The file object or path of the model in which it is to be stored.
+        """
+        estimator.save_model(model_path)
+
+
+class XgboostTxtModelSerializer(ModelSerializer):
+    """Save Xgboost Model through xgboost.save_model into txt."""
+
+    def __init__(self, model_file_suffix="txt"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        """Save Xgboost Model through xgboost.save_model .See
+        https://xgboost.readthedocs.io/en/stable/python/python_api.html#xgboost.Booster.save_model
+        for more details.
+
+        Args:
+            estimator: The model to be saved.
+            model_path: The file object or path of the model in which it is to be stored.
+        """
+        estimator.save_model(model_path)
+
+
+class XgboostUbjModelSerializer(ModelSerializer):
+    """Save Xgboost Model through xgboost.save_model into binary JSON."""
+
+    def __init__(self, model_file_suffix="ubj"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        """Save Xgboost Model through xgboost.save_model .See
+        https://xgboost.readthedocs.io/en/stable/python/python_api.html#xgboost.Booster.save_model
+        for more details.
+
+        Args:
+            estimator: The model to be saved.
+            model_path: The file object or path of the model in which it is to be stored.
+        """
+        estimator.save_model(model_path)
+
+
+class TensorFlowModelSerializer(ModelSerializer):
+    """Save Tensorflow Model."""
+
+    def __init__(self, model_file_suffix="h5"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        estimator.save(model_path)
+
+
+class HuggingFaceModelSerializer(ModelSerializer):
+    """Save HuggingFace Pipeline."""
+
+    def __init__(self, model_file_suffix=""):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(self, estimator, model_path, **kwargs):
+        estimator.save_pretrained(save_directory=model_path)
+        estimator.model.config.use_pretrained_backbone = False
+        estimator.model.config.save_pretrained(save_directory=model_path)
+
+
+class OnnxModelSerializer(ModelSerializer):
+    """Base class for creation of onnx converter for each model framework."""
+
+    def __init__(self, model_file_suffix="onnx"):
+        super().__init__(model_file_suffix=model_file_suffix)
+
+    def serialize(
+        self,
+        estimator,
+        model_path,
+        initial_types: List[Tuple] = None,
+        X_sample: Optional[
+            Union[
+                Dict,
+                str,
+                List,
+                Tuple,
+                np.ndarray,
+                pd.core.series.Series,
+                pd.core.frame.DataFrame,
+            ]
+        ] = None,
+        **kwargs,
+    ):
+        """Save model into onnx format.
+
+        Args:
+            estimator: The model to be saved.
+            model_path: The file object or path of the model in which it is to be stored.
+            initial_types: (List[Tuple], optional)
+                a python list. Each element is a tuple of a variable name and a data type.
+            X_sample: (any, optional). Defaults to None.
+                Contains model inputs such that model(X_sample) is a valid
+                invocation of the model, used to valid model input type.
+        """
+        self.estimator = estimator
+        onx = self._to_onnx(
+            initial_types=initial_types,
+            X_sample=X_sample,
+            **kwargs,
+        )
+        with open(model_path, "wb") as f:
+            f.write(onx.SerializeToString())
+
+    def _to_onnx(
+        self,
+        initial_types: List[Tuple] = None,
+        X_sample: Optional[
+            Union[
+                Dict,
+                str,
+                List,
+                Tuple,
+                np.ndarray,
+                pd.core.series.Series,
+                pd.core.frame.DataFrame,
+            ]
+        ] = None,
+        **kwargs,
+    ):
+        raise NotImplementedError
+
+
+class SklearnOnnxModelSerializer(OnnxModelSerializer):
+    """Converts Skearn Model into Onnx."""
+
+    def __init__(self):
+        super().__init__()
+
+    @runtime_dependency(module="onnx", install_from=OptionalDependency.ONNX)
+    @runtime_dependency(module="xgboost", install_from=OptionalDependency.BOOSTED)
+    @runtime_dependency(module="lightgbm", install_from=OptionalDependency.BOOSTED)
+    @runtime_dependency(module="skl2onnx", install_from=OptionalDependency.ONNX)
+    @runtime_dependency(module="onnxmltools", install_from=OptionalDependency.ONNX)
+    @runtime_dependency(
+        module="onnxmltools.convert.xgboost.operator_converters.XGBoost",
+        object="convert_xgboost",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(
+        module="onnxmltools.convert.lightgbm.operator_converters.LightGbm",
+        object="convert_lightgbm",
+        install_from=OptionalDependency.ONNX,
+    )
+    def _to_onnx(
+        self,
+        initial_types: List[Tuple] = None,
+        X_sample: Optional[
+            Union[
+                Dict,
+                str,
+                List,
+                Tuple,
+                np.ndarray,
+                pd.core.series.Series,
+                pd.core.frame.DataFrame,
+            ]
+        ] = None,
+        **kwargs,
+    ):
+        """
+        Produces an equivalent ONNX model of the given scikit-learn model.
+
+        Parameters
+        ----------
+        initial_types: (List[Tuple], optional). Defaults to None.
+            Each element is a tuple of a variable name and a type.
+        X_sample: Union[Dict, str, List, np.ndarray, pd.core.series.Series, pd.core.frame.DataFrame,]. Defaults to None.
+            Contains model inputs such that model(X_sample) is a valid invocation of the model.
+            Used to generate initial_types.
+
+        Returns
+        -------
+        onnx.onnx_ml_pb2.ModelProto
+            An ONNX model (type: ModelProto) which is equivalent to the input scikit-learn model.
+        """
+        auto_generated_initial_types = None
+        if not initial_types:
+            if X_sample is None:
+                raise ValueError(
+                    " At least one of `X_sample` or `initial_types` must be provided."
+                )
+            auto_generated_initial_types = self._generate_initial_types(X_sample)
+        if str(type(self.estimator)).startswith("<class 'sklearn.pipeline"):
+            model_types = []
+            model_types = [type(val[1]) for val in self.estimator.steps]
+            if xgboost.sklearn.XGBClassifier in model_types:
+                skl2onnx.update_registered_converter(
+                    xgboost.XGBClassifier,
+                    "XGBoostXGBClassifier",
+                    skl2onnx.common.shape_calculator.calculate_linear_classifier_output_shapes,
+                    convert_xgboost,
+                    options=kwargs.pop(
+                        "options", {"nocl": [True, False], "zipmap": [True, False]}
+                    ),
+                )
+
+            if xgboost.sklearn.XGBRegressor in model_types:
+                skl2onnx.update_registered_converter(
+                    xgboost.XGBRegressor,
+                    "XGBoostXGBRegressor",
+                    skl2onnx.common.shape_calculator.calculate_linear_regressor_output_shapes,
+                    convert_xgboost,
+                )
+
+            if lightgbm.sklearn.LGBMClassifier in model_types:
+                skl2onnx.update_registered_converter(
+                    lightgbm.LGBMClassifier,
+                    "LightGbmLGBMClassifier",
+                    skl2onnx.common.shape_calculator.calculate_linear_classifier_output_shapes,
+                    convert_lightgbm,
+                    options=kwargs.pop(
+                        "options",
+                        {"nocl": [True, False], "zipmap": [True, False, "columns"]},
+                    ),
+                )
+
+            if lightgbm.sklearn.LGBMRegressor in model_types:
+
+                def skl2onnx_convert_lightgbm(scope, operator, container):
+                    options = scope.get_options(operator.raw_operator)
+                    if "split" in options:
+                        if StrictVersion(onnxmltools.__version__) < StrictVersion(
+                            "1.9.2"
+                        ):
+                            logger.warnings(
+                                "Option split was released in version 1.9.2 but %s is "
+                                "installed. It will be ignored."
+                                % onnxmltools.__version__
+                            )
+                        operator.split = options["split"]
+                    else:
+                        operator.split = None
+                    convert_lightgbm(scope, operator, container)
+
+                skl2onnx.update_registered_converter(
+                    lightgbm.LGBMRegressor,
+                    "LightGbmLGBMRegressor",
+                    skl2onnx.common.shape_calculator.calculate_linear_regressor_output_shapes,
+                    skl2onnx_convert_lightgbm,
+                    options=kwargs.pop("options", {"split": None}),
+                )
+            if initial_types:
+                return skl2onnx.convert_sklearn(
+                    self.estimator, initial_types=initial_types, **kwargs
+                )
+            else:
+                try:
+                    return skl2onnx.convert_sklearn(
+                        self.estimator,
+                        initial_types=auto_generated_initial_types,
+                        target_opset=None,
+                        **kwargs,
+                    )
+                except Exception as e:
+                    raise ValueError(
+                        "`initial_types` can not be autodetected. Please directly pass `initial_types`."
+                    )
+        else:
+            if initial_types:
+                return onnxmltools.convert_sklearn(
+                    self.estimator,
+                    initial_types=initial_types,
+                    targeted_onnx=onnx.__version__,
+                    **kwargs,
+                )
+            else:
+                try:
+                    return onnxmltools.convert_sklearn(
+                        self.estimator,
+                        initial_types=auto_generated_initial_types,
+                        targeted_onnx=onnx.__version__,
+                        **kwargs,
+                    )
+                except Exception as e:
+                    raise ValueError(
+                        "`initial_types` can not be detected. Please directly pass initial_types."
+                    )
+
+    @runtime_dependency(module="skl2onnx", install_from=OptionalDependency.ONNX)
+    def _generate_initial_types(self, X_sample: Any) -> List:
+        """Auto generate intial types.
+
+        Parameters
+        ----------
+        X_sample: (Any)
+            Train data.
+
+        Returns
+        -------
+        List
+            Initial types.
+        """
+        if self._is_all_numerical_array_dataframe(X_sample):
+            # if it's a dataframe and all the columns are numerical. Or
+            # it's not a dataframe, also try this.
+            if hasattr(X_sample, "shape") and len(X_sample.shape) >= 2:
+                auto_generated_initial_types = [
+                    (
+                        "input",
+                        skl2onnx.common.data_types.FloatTensorType(
+                            [None, X_sample.shape[1]]
+                        ),
+                    )
+                ]
+            elif hasattr(self.estimator, "n_features_in_"):
+                n_cols = self.estimator.n_features_in_
+                auto_generated_initial_types = [
+                    (
+                        "input",
+                        skl2onnx.common.data_types.FloatTensorType([None, n_cols]),
+                    )
+                ]
+            else:
+                raise ValueError(
+                    "`initial_types` can not be detected. Please directly pass initial_types."
+                )
+        elif self.is_either_numerical_or_string_dataframe(X_sample):
+            # for dataframe and not all the columns are numerical, then generate
+            # the input types of all the columns one by one.
+            auto_generated_initial_types = []
+
+            for i, col in X_sample.items():
+                if is_numeric_dtype(col.dtypes):
+                    auto_generated_initial_types.append(
+                        (
+                            col.name,
+                            skl2onnx.common.data_types.FloatTensorType([None, 1]),
+                        )
+                    )
+                else:
+                    auto_generated_initial_types.append(
+                        (
+                            col.name,
+                            skl2onnx.common.data_types.StringTensorType([None, 1]),
+                        )
+                    )
+        else:
+            try:
+                auto_generated_initial_types = (
+                    skl2onnx.common.data_types.guess_data_type(
+                        np.array(X_sample) if isinstance(X_sample, list) else X_sample
+                    )
+                )
+            except:
+                auto_generated_initial_types = None
+        return auto_generated_initial_types
+
+    @staticmethod
+    def _is_all_numerical_array_dataframe(
+        data: Union[pd.DataFrame, np.ndarray]
+    ) -> bool:
+        """Check whether all the columns are numerical for numpy array and dataframe.
+        For data with any other data types, it will return False.
+
+        Parameters
+        ----------
+        data: Union[pd.DataFrame, np.ndarray]
+
+        Returns
+        -------
+        bool
+            Whether all the columns in a pandas dataframe or numpy array are all numerical.
+        """
+        return (
+            isinstance(data, pd.DataFrame)
+            and all([is_numeric_dtype(dtype) for dtype in data.dtypes])
+            or (isinstance(data, np.ndarray) and is_numeric_dtype(data.dtype))
+        )
+
+    @staticmethod
+    def is_either_numerical_or_string_dataframe(data: pd.DataFrame) -> bool:
+        """Check whether all the columns are either numerical or string for dataframe."""
+        return isinstance(data, pd.DataFrame) and all(
+            [
+                is_numeric_dtype(col.dtypes) or is_string_dtype(col.dtypes)
+                for _, col in data.items()
+            ]
+        )
+
+
+class LightGBMOnnxModelSerializer(OnnxModelSerializer):
+    """Converts LightGBM model into onnx format."""
+
+    def __init__(self):
+        super().__init__()
+
+    @runtime_dependency(
+        module="skl2onnx.common.data_types",
+        object="FloatTensorType",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(
+        module="onnxmltools.convert",
+        object="convert_lightgbm",
+        install_from=OptionalDependency.ONNX,
+    )
+    def _to_onnx(
+        self,
+        initial_types: List[Tuple] = None,
+        X_sample: Optional[
+            Union[
+                Dict,
+                str,
+                List,
+                Tuple,
+                np.ndarray,
+                pd.core.series.Series,
+                pd.core.frame.DataFrame,
+            ]
+        ] = None,
+        **kwargs,
+    ):
+        """
+        Produces an equivalent ONNX model of the given LightGBM model.
+
+        Parameters
+        ----------
+        initial_types: (List[Tuple], optional). Defaults to None.
+            Each element is a tuple of a variable name and a type.
+        X_sample: Union[Dict, str, List, np.ndarray, pd.core.series.Series, pd.core.frame.DataFrame,]. Defaults to None.
+            Contains model inputs such that model(X_sample) is a valid invocation of the model.
+            Used to generate initial_types.
+
+        Returns
+        ------
+            An ONNX model (type: ModelProto) which is equivalent to the input LightGBM model.
+        """
+        auto_generated_initial_types = None
+        if not initial_types:
+            auto_generated_initial_types = self._generate_initial_types(X_sample)
+            try:
+                return convert_lightgbm(
+                    self.estimator,
+                    initial_types=auto_generated_initial_types,
+                    target_opset=kwargs.pop("target_opset", None),
+                    **kwargs,
+                )
+            except:
+                raise ValueError(
+                    "`initial_types` can not be detected. Please directly pass initial_types."
+                )
+        else:
+            return convert_lightgbm(
+                self.estimator,
+                initial_types=initial_types,
+                target_opset=kwargs.pop("target_opset", None),
+                **kwargs,
+            )
+
+    @runtime_dependency(
+        module="skl2onnx.common.data_types",
+        object="FloatTensorType",
+        install_from=OptionalDependency.ONNX,
+    )
+    def _generate_initial_types(self, X_sample: Any) -> List:
+        """Auto generate intial types.
+
+        Parameters
+        ----------
+        X_sample: (Any)
+            Train data.
+
+        Returns
+        -------
+        List
+            Initial types.
+        """
+        if X_sample is not None and hasattr(X_sample, "shape"):
+            auto_generated_initial_types = [
+                ("input", FloatTensorType([None, X_sample.shape[1]]))
+            ]
+        elif hasattr(self.estimator, "num_feature"):
+            n_cols = self.estimator.num_feature()
+            auto_generated_initial_types = [("input", FloatTensorType([None, n_cols]))]
+        elif hasattr(self.estimator, "n_features_in_"):
+            n_cols = self.estimator.n_features_in_
+            auto_generated_initial_types = [("input", FloatTensorType([None, n_cols]))]
+        else:
+            raise ValueError(
+                "`initial_types` can not be detected. Please directly pass initial_types."
+            )
+        return auto_generated_initial_types
+
+
+class XgboostOnnxModelSerializer(OnnxModelSerializer):
+    """Converts Xgboost model into onnx format."""
+
+    def __init__(self):
+        super().__init__()
+
+    @runtime_dependency(module="onnx", install_from=OptionalDependency.ONNX)
+    @runtime_dependency(module="xgboost", install_from=OptionalDependency.BOOSTED)
+    @runtime_dependency(
+        module="skl2onnx",
+        object="convert_sklearn",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(
+        module="skl2onnx",
+        object="update_registered_converter",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(
+        module="skl2onnx.common.data_types",
+        object="FloatTensorType",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(
+        module="skl2onnx.common.shape_calculator",
+        object="calculate_linear_classifier_output_shapes",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(
+        module="skl2onnx.common.shape_calculator",
+        object="calculate_linear_regressor_output_shapes",
+        install_from=OptionalDependency.ONNX,
+    )
+    @runtime_dependency(module="onnxmltools", install_from=OptionalDependency.ONNX)
+    @runtime_dependency(
+        module="onnxmltools.convert.xgboost.operator_converters.XGBoost",
+        object="convert_xgboost",
+        install_from=OptionalDependency.ONNX,
+    )
+    def _to_onnx(
+        self,
+        initial_types: List[Tuple] = None,
+        X_sample: Union[list, tuple, pd.DataFrame, pd.Series, np.ndarray] = None,
+        **kwargs,
+    ):
+        """
+        Produces an equivalent ONNX model of the given Xgboost model.
+
+        Parameters
+        ----------
+        initial_types: (List[Tuple], optional). Defaults to None.
+            Each element is a tuple of a variable name and a type.
+        X_sample: Union[Dict, str, List, np.ndarray, pd.core.series.Series, pd.core.frame.DataFrame,]. Defaults to None.
+            Contains model inputs such that model(X_sample) is a valid invocation of the model.
+            Used to generate initial_types.
+
+        Returns
+        -------
+        onnx.onnx_ml_pb2.ModelProto
+            An ONNX model (type: ModelProto) which is equivalent to the input xgboost model.
+        """
+        auto_generated_initial_types = None
+        if not initial_types:
+            auto_generated_initial_types = self._generate_initial_types(X_sample)
+
+        model_types = []
+        if str(type(self.estimator)).startswith("<class 'xgboost.sklearn."):
+            model_types.append(type(self.estimator))
+
+        if model_types:
+            if xgboost.sklearn.XGBClassifier in model_types:
+                update_registered_converter(
+                    xgboost.XGBClassifier,
+                    "XGBoostXGBClassifier",
+                    calculate_linear_classifier_output_shapes,
+                    convert_xgboost,
+                    options={"nocl": [True, False], "zipmap": [True, False]},
+                )
+            elif xgboost.sklearn.XGBRegressor in model_types:
+                update_registered_converter(
+                    xgboost.XGBRegressor,
+                    "XGBoostXGBRegressor",
+                    calculate_linear_regressor_output_shapes,
+                    convert_xgboost,
+                )
+            if initial_types:
+                return convert_sklearn(
+                    self.estimator, initial_types=initial_types, **kwargs
+                )
+            else:
+                try:
+                    return convert_sklearn(
+                        self.estimator,
+                        initial_types=auto_generated_initial_types,
+                        **kwargs,
+                    )
+                except:
+                    raise ValueError(
+                        "`initial_types` can not be autodetected. Please directly pass `initial_types`."
+                    )
+        else:
+            # xgboost api
+            if initial_types:
+                return onnxmltools.convert_xgboost(
+                    self.estimator,
+                    initial_types=initial_types,
+                    target_opset=kwargs.pop("target_opset", None),
+                    targeted_onnx=onnx.__version__,
+                    **kwargs,
+                )
+            else:
+                try:
+                    return onnxmltools.convert_xgboost(
+                        self.estimator,
+                        initial_types=auto_generated_initial_types,
+                        target_opset=kwargs.pop("target_opset", None),
+                        targeted_onnx=onnx.__version__,
+                        **kwargs,
+                    )
+                except:
+                    raise ValueError(
+                        "`initial_types` can not be autodetected. Please directly pass `initial_types`."
+                    )
+
+    @runtime_dependency(
+        module="skl2onnx.common.data_types",
+        object="FloatTensorType",
+        install_from=OptionalDependency.ONNX,
+    )
+    def _generate_initial_types(self, X_sample: Any) -> List:
+        """Auto generate intial types.
+
+        Parameters
+        ----------
+        X_sample: (Any)
+            Train data.
+
+        Returns
+        -------
+        List
+            Initial types.
+        """
+        if hasattr(self.estimator, "n_features_in_"):
+            # sklearn api
+            n_cols = self.estimator.n_features_in_
+            return [("input", FloatTensorType([None, n_cols]))]
+        elif hasattr(self.estimator, "feature_names") and self.estimator.feature_names:
+            # xgboost learning api
+            n_cols = len(self.estimator.feature_names)
+            return [("input", FloatTensorType([None, n_cols]))]
+        if X_sample is None:
+            raise ValueError(
+                " At least one of `X_sample` or `initial_types` must be provided."
+            )
+        if (
+            X_sample is not None
+            and hasattr(X_sample, "shape")
+            and len(X_sample.shape) >= 2
+        ):
+            auto_generated_initial_types = [
+                ("input", FloatTensorType([None, X_sample.shape[1]]))
+            ]
+        else:
+            raise ValueError(
+                "`initial_types` can not be detected. Please directly pass initial_types."
+            )
+        return auto_generated_initial_types
+
+
+class PytorchOnnxModelSerializer(OnnxModelSerializer):
+    """Converts Pytorch model into onnx format."""
+
+    def __init__(self):
+        super().__init__()
+
+    @runtime_dependency(module="torch", install_from=OptionalDependency.PYTORCH)
+    def serialize(
+        self,
+        estimator,
+        model_path: str,
+        X_sample: Optional[
+            Union[
+                Dict,
+                str,
+                List,
+                Tuple,
+                np.ndarray,
+                pd.core.series.Series,
+                pd.core.frame.DataFrame,
+            ]
+        ] = None,
+        **kwargs,
+    ):
+        """
+        Exports the given Pytorch model into ONNX format.
+
+        Parameters
+        ----------
+        path: str, default to None
+            Path to save the serialized model.
+        onnx_args: (tuple or torch.Tensor), default to None
+            Contains model inputs such that model(onnx_args) is a valid
+            invocation of the model. Can be structured either as: 1) ONLY A
+            TUPLE OF ARGUMENTS; 2) A TENSOR; 3) A TUPLE OF ARGUMENTS ENDING
+            WITH A DICTIONARY OF NAMED ARGUMENTS
+        X_sample: Union[list, tuple, pd.Series, np.ndarray, pd.DataFrame]. Defaults to None.
+            A sample of input data that will be used to generate input schema and detect onnx_args.
+        kwargs:
+            input_names: (List[str], optional). Defaults to ["input"].
+                Names to assign to the input nodes of the graph, in order.
+            output_names: (List[str], optional). Defaults to ["output"].
+                Names to assign to the output nodes of the graph, in order.
+            dynamic_axes: (dict, optional). Defaults to None.
+                Specify axes of tensors as dynamic (i.e. known only at run-time).
+
+        Returns
+        -------
+        None
+            Nothing
+
+        Raises
+        ------
+        AssertionError
+            if onnx module is not support by the current version of torch
+        ValueError
+            if X_sample is not provided
+            if path is not provided
+        """
+        onnx_args = kwargs.get("onnx_args", None)
+        input_names = kwargs.get("input_names", ["input"])
+        output_names = kwargs.get("output_names", ["output"])
+        dynamic_axes = kwargs.get("dynamic_axes", None)
+
+        assert hasattr(torch, "onnx"), (
+            f"This version of pytorch {torch.__version__} does not appear to support onnx "
+            "conversion."
+        )
+
+        if onnx_args is None:
+            if X_sample is not None:
+                logger.warning(
+                    "Since `onnx_args` is not provided, `onnx_args` is "
+                    "detected from `X_sample` to export pytorch model as onnx."
+                )
+                onnx_args = X_sample
+            else:
+                raise ValueError(
+                    "`onnx_args` can not be detected. The parameter `onnx_args` must be provided to export pytorch model as onnx."
+                )
+
+        if not model_path:
+            raise ValueError(
+                "The parameter `model_path` must be provided to save the model file."
+            )
+
+        torch.onnx.export(
+            estimator,
+            args=onnx_args,
+            f=model_path,
+            input_names=input_names,
+            output_names=output_names,
+            dynamic_axes=dynamic_axes,
+        )
+
+
+class TensorFlowOnnxModelSerializer(OnnxModelSerializer):
+    """Converts Tensorflow model into onnx format."""
+
+    def __init__(self):
+        super().__init__()
+
+    @runtime_dependency(module="tf2onnx", install_from=OptionalDependency.ONNX)
+    @runtime_dependency(
+        module="tensorflow",
+        short_name="tf",
+        install_from=OptionalDependency.TENSORFLOW,
+    )
+    def serialize(
+        self,
+        estimator,
+        model_path: str = None,
+        X_sample: Optional[
+            Union[
+                Dict,
+                str,
+                List,
+                Tuple,
+                np.ndarray,
+                pd.core.series.Series,
+                pd.core.frame.DataFrame,
+            ]
+        ] = None,
+        **kwargs,
+    ):
+        """
+        Exports the given Tensorflow model into ONNX format.
+
+        Parameters
+        ----------
+        model_path: str, default to None
+            Path to save the serialized model.
+        X_sample: Union[list, tuple, pd.Series, np.ndarray, pd.DataFrame]. Defaults to None.
+            A sample of input data that will be used to generate input schema and detect input_signature.
+
+
+        Returns
+        -------
+        None
+            Nothing
+
+        Raises
+        ------
+        ValueError
+            if model_path is not provided
+        """
+        opset_version = kwargs.get("opset_version", None)
+        input_signature = kwargs.get("input_signature", None)
+
+        if not model_path:
+            raise ValueError(
+                "The parameter `model_path` must be provided to save the model file."
+            )
+        if input_signature is None:
+            if hasattr(estimator, "input_shape"):
+                if not isinstance(estimator.input, list):
+                    # single input
+                    detected_input_signature = (
+                        tf.TensorSpec(
+                            estimator.input_shape,
+                            dtype=estimator.input.dtype,
+                            name="input",
+                        ),
+                    )
+                else:
+                    # multiple input
+                    detected_input_signature = []
+                    for i in range(len(estimator.input)):
+                        detected_input_signature.append(
+                            tf.TensorSpec(
+                                estimator.input_shape[i],
+                                dtype=estimator.input[i].dtype,
+                            )
+                        )
+
+            elif X_sample is not None and hasattr(X_sample, "shape"):
+                logger.warning(
+                    "Since `input_signature` is not provided, `input_signature` is "
+                    "detected from `X_sample` to export tensorflow model as "
+                    "onnx."
+                )
+                X_sample_shape = list(X_sample.shape)
+                X_sample_shape[0] = None
+                detected_input_signature = (
+                    tf.TensorSpec(X_sample_shape, dtype=X_sample.dtype, name="input"),
+                )
+            else:
+                raise ValueError(
+                    "The parameter `input_signature` must be provided to export "
+                    "tensorflow model as onnx."
+                )
+            try:
+                tf2onnx.convert.from_keras(
+                    estimator,
+                    input_signature=detected_input_signature,
+                    opset=opset_version,
+                    output_path=model_path,
+                )
+            except:
+                raise ValueError(
+                    "`input_signature` can not be autodetected. The parameter `input_signature` must be provided to export "
+                    "tensorflow model as onnx."
+                )
+
+        else:
+            tf2onnx.convert.from_keras(
+                estimator,
+                input_signature=input_signature,
+                opset=opset_version,
+                output_path=model_path,
+            )
+
+
+class OnnxModelSaveSERDE(OnnxModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_ONNX
+
+
+class CloudpickleModelSaveSERDE(CloudPickleModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_CLOUDPICKLE
+
+
+class JoblibModelSaveSERDE(JobLibModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_JOBLIB
+
+
+class SparkModelSaveSERDE(SparkModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_SPARK
+
+
+class HuggingFacePipelineSaveSERDE(HuggingFaceModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_HUGGINGFACE
+
+
+class TorchScriptModelSaveSERDE(TorchScriptModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_TORHCSCRIPT
+
+
+class PyTorchModelSaveSERDE(PyTorchModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_TORCH
+
+
+class PyTorchOnnxModelSaveSERDE(PytorchOnnxModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_TORCH_ONNX
+
+
+class TensorFlowModelSaveSERDE(TensorFlowModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_TF
+
+
+class TensorFlowOnnxModelSaveSERDE(TensorFlowOnnxModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_TF_ONNX
+
+
+class SklearnOnnxModelSaveSERDE(SklearnOnnxModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_SKLEARN_ONNX
+
+
+class LightGBMModelSaveSERDE(LightGBMModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_LIGHTGBM
+
+
+class LightGBMOnnxModelSaveSERDE(LightGBMOnnxModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_LIGHTGBM_ONNX
+
+
+class XgboostJsonModelSaveSERDE(XgboostJsonModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_XGBOOST
+
+
+class XgboostUbjModelSaveSERDE(XgboostUbjModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_XGBOOST_UBJ
+
+
+class XgboostTxtModelSaveSERDE(XgboostTxtModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_XGBOOST_TXT
+
+
+class XgboostOnnxModelSaveSERDE(XgboostOnnxModelSerializer, ModelDeserializer):
+    name = MODEL_SERIALIZATION_TYPE_XGBOOST_ONNX
+
+
+class ModelSerializerFactory:
+    """Model Serializer Factory.
+
+    Returns
+    -------
+    model_save_serde: Intance of `ads.model.SERDE`".
+    """
+
+    _factory = {}
+    _factory[MODEL_SERIALIZATION_TYPE_CLOUDPICKLE] = CloudpickleModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_ONNX] = OnnxModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_TORHCSCRIPT] = TorchScriptModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_TORCH] = PyTorchModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_TORCH_ONNX] = PyTorchOnnxModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_TF] = TensorFlowModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_TF_ONNX] = TensorFlowOnnxModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_JOBLIB] = JoblibModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_SKLEARN_ONNX] = SklearnOnnxModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_LIGHTGBM] = LightGBMModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_LIGHTGBM_ONNX] = LightGBMOnnxModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_XGBOOST] = XgboostJsonModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_XGBOOST_UBJ] = XgboostUbjModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_XGBOOST_TXT] = XgboostTxtModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_XGBOOST_ONNX] = XgboostOnnxModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_SPARK] = SparkModelSaveSERDE
+    _factory[MODEL_SERIALIZATION_TYPE_HUGGINGFACE] = HuggingFacePipelineSaveSERDE
+
+    @classmethod
+    def get(cls, se: str):
+        serde = cls._factory.get(se, None)
+        if serde:
+            return serde()
+        else:
+            raise ValueError(
+                f"This {se} format is not supported."
+                f"Currently support the following format: {SUPPORTED_MODEL_SERIALIZERS}."
+            )