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

snowflake/ml/modeling/preprocessing/one_hot_encoder.py

@@ -101,16 +101,20 @@ class OneHotEncoder(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html).
 
     Args:
-        categories: 'auto' or dict {column_name: np.ndarray([category])}, default='auto'
+        categories: 'auto', list of array-like, or dict {column_name: np.ndarray([category])}, default='auto'
             Categories (unique values) per feature:
             - 'auto': Determine categories automatically from the training data.
+            - list: ``categories[i]`` holds the categories expected in the ith
+            column. The passed categories should not mix strings and numeric
+            values within a single feature, and should be sorted in case of
+            numeric values.
             - dict: ``categories[column_name]`` holds the categories expected in
               the column provided. The passed categories should not mix strings
               and numeric values within a single feature, and should be sorted in
               case of numeric values.
             The used categories can be found in the ``categories_`` attribute.
 
-        drop: {‘first’, ‘if_binary’} or an array-like of shape (n_features,), default=None
+        drop: {'first', 'if_binary'} or an array-like of shape (n_features,), default=None
             Specifies a methodology to use to drop one of the categories per
             feature. This is useful in situations where perfectly collinear
             features cause problems, such as when feeding the resulting data
@@ -206,7 +210,7 @@ class OneHotEncoder(base.BaseTransformer):
     def __init__(
         self,
         *,
-        categories: Union[str, Dict[str, type_utils.LiteralNDArrayType]] = "auto",
+        categories: Union[str, List[type_utils.LiteralNDArrayType], Dict[str, type_utils.LiteralNDArrayType]] = "auto",
         drop: Optional[Union[str, npt.ArrayLike]] = None,
         sparse: bool = False,
         handle_unknown: str = "error",
@@ -440,8 +444,19 @@ class OneHotEncoder(base.BaseTransformer):
         assert found_state_df is not None
         if self.categories != "auto":
             state_data = []
-            assert isinstance(self.categories, dict)
-            for input_col, cats in self.categories.items():
+            if isinstance(self.categories, list):
+                categories_map = {col_name: cats for col_name, cats in zip(self.input_cols, self.categories)}
+            elif isinstance(self.categories, dict):
+                categories_map = self.categories
+            else:
+                raise exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT,
+                    original_exception=ValueError(
+                        f"Invalid type {type(self.categories)} provided for argument `categories`"
+                    ),
+                )
+
+            for input_col, cats in categories_map.items():
                 for cat in cats.tolist():
                     state_data.append([input_col, cat])
             # states of given categories
@@ -565,6 +580,8 @@ class OneHotEncoder(base.BaseTransformer):
                     else:
                         categories[k] = vectorized_func(v)
             self.categories_ = categories
+        elif isinstance(self.categories, list):
+            self.categories_ = {col_name: cats for col_name, cats in zip(self.input_cols, self.categories)}
         else:
             self.categories_ = self.categories
 
@@ -850,8 +867,15 @@ class OneHotEncoder(base.BaseTransformer):
         # In case of fitting with pandas dataframe and transforming with snowpark dataframe
         # state_pandas cannot recognize the datatype of _CATEGORY and _FITTED_CATEGORY column
         # Therefore, apply the convert_to_string_excluding_nan function to _CATEGORY and _FITTED_CATEGORY
-        state_pandas[[_CATEGORY]] = state_pandas[[_CATEGORY]].applymap(convert_to_string_excluding_nan)
-        state_pandas[[_FITTED_CATEGORY]] = state_pandas[[_FITTED_CATEGORY]].applymap(convert_to_string_excluding_nan)
+        # applymap is depreciated since pandas 2.1.0, replaced by map
+        if pd.__version__ < "2.1.0":
+            state_pandas[[_CATEGORY]] = state_pandas[[_CATEGORY]].applymap(convert_to_string_excluding_nan)
+            state_pandas[[_FITTED_CATEGORY]] = state_pandas[[_FITTED_CATEGORY]].applymap(
+                convert_to_string_excluding_nan
+            )
+        else:
+            state_pandas[[_CATEGORY]] = state_pandas[[_CATEGORY]].map(convert_to_string_excluding_nan)
+            state_pandas[[_FITTED_CATEGORY]] = state_pandas[[_FITTED_CATEGORY]].map(convert_to_string_excluding_nan)
         state_df = dataset._session.create_dataframe(state_pandas)
 
         transformed_dataset = dataset
@@ -1009,7 +1033,7 @@ class OneHotEncoder(base.BaseTransformer):
                 error_code=error_codes.INVALID_ATTRIBUTE,
                 original_exception=ValueError(f"Unsupported `categories` value: {self.categories}."),
             )
-        elif isinstance(self.categories, dict):
+        elif isinstance(self.categories, (dict, list)):
             if len(self.categories) != len(self.input_cols):
                 raise exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_ATTRIBUTE,
@@ -1018,7 +1042,7 @@ class OneHotEncoder(base.BaseTransformer):
                         f"({len(self.input_cols)})."
                     ),
                 )
-            elif set(self.categories.keys()) != set(self.input_cols):
+            elif isinstance(self.categories, dict) and set(self.categories.keys()) != set(self.input_cols):
                 raise exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_ATTRIBUTE,
                     original_exception=ValueError(
@@ -1537,6 +1561,16 @@ class OneHotEncoder(base.BaseTransformer):
         default_sklearn_args = _utils.get_default_args(default_sklearn_obj.__class__.__init__)
         given_args = self.get_params()
 
+        if "categories" in given_args and isinstance(given_args["categories"], dict):
+            # sklearn requires a list of array-like to satisfy the `categories` arg
+            try:
+                given_args["categories"] = [given_args["categories"][input_col] for input_col in self.input_cols]
+            except KeyError as e:
+                raise exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT,
+                    original_exception=e,
+                )
+
         # replace 'sparse' with 'sparse_output' when scikit-learn>=1.2
         sklearn_version = sklearn.__version__
         if version.parse(sklearn_version) >= version.parse(_SKLEARN_DEPRECATED_KEYWORD_TO_VERSION_DICT["sparse"]):

snowflake/ml/modeling/preprocessing/ordinal_encoder.py

@@ -45,9 +45,11 @@ class OrdinalEncoder(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html).
 
     Args:
-        categories: Union[str, Dict[str, type_utils.LiteralNDArrayType]], default="auto"
+        categories: Union[str, List[type_utils.LiteralNDArrayType], Dict[str, type_utils.LiteralNDArrayType]],
+        default="auto"
             The string 'auto' (the default) causes the categories to be extracted from the input columns.
-            To specify the categories yourself, pass a dictionary mapping the column name to an ndarray containing the
+            To specify the categories yourself, pass either (1) a list of ndarrays containing the categories or
+            (2) a dictionary mapping the column name to an ndarray containing the
             categories.
 
         handle_unknown: str, default="error"
@@ -96,7 +98,7 @@ class OrdinalEncoder(base.BaseTransformer):
     def __init__(
         self,
         *,
-        categories: Union[str, Dict[str, type_utils.LiteralNDArrayType]] = "auto",
+        categories: Union[str, List[type_utils.LiteralNDArrayType], Dict[str, type_utils.LiteralNDArrayType]] = "auto",
         handle_unknown: str = "error",
         unknown_value: Optional[Union[int, float]] = None,
         encoded_missing_value: Union[int, float] = np.nan,
@@ -114,9 +116,13 @@ class OrdinalEncoder(base.BaseTransformer):
         a single column of integers (0 to n_categories - 1) per feature.
 
         Args:
-            categories: 'auto' or dict {column_name: ndarray([category])}, default='auto'
+            categories: 'auto', list of array-like, or dict {column_name: ndarray([category])}, default='auto'
                 Categories (unique values) per feature:
                 - 'auto': Determine categories automatically from the training data.
+                - list: ``categories[i]`` holds the categories expected in the ith
+                  column. The passed categories should not mix strings and numeric
+                  values within a single feature, and should be sorted in case of
+                  numeric values.
                 - dict: ``categories[column_name]`` holds the categories expected in
                   the column provided. The passed categories should not mix strings
                   and numeric values within a single feature, and should be sorted in
@@ -317,8 +323,19 @@ class OrdinalEncoder(base.BaseTransformer):
         assert found_state_df is not None
         if self.categories != "auto":
             state_data = []
-            assert isinstance(self.categories, dict)
-            for input_col, cats in self.categories.items():
+            if isinstance(self.categories, list):
+                categories_map = {col_name: cats for col_name, cats in zip(self.input_cols, self.categories)}
+            elif isinstance(self.categories, dict):
+                categories_map = self.categories
+            else:
+                raise exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT,
+                    original_exception=ValueError(
+                        f"Invalid type {type(self.categories)} provided for argument `categories`"
+                    ),
+                )
+
+            for input_col, cats in categories_map.items():
                 for idx, cat in enumerate(cats.tolist()):
                     state_data.append([input_col, cat, idx])
             # states of given categories
@@ -368,6 +385,8 @@ class OrdinalEncoder(base.BaseTransformer):
                 for col_name, cats in grouped_categories.items()
             }
             self.categories_ = categories
+        elif isinstance(self.categories, list):
+            self.categories_ = {col_name: cats for col_name, cats in zip(self.input_cols, self.categories)}
         else:
             self.categories_ = self.categories
 
@@ -548,6 +567,15 @@ class OrdinalEncoder(base.BaseTransformer):
             snowml_only_keywords=_SNOWML_ONLY_KEYWORDS,
             sklearn_added_keyword_to_version_dict=_SKLEARN_ADDED_KEYWORD_TO_VERSION_DICT,
         )
+        if "categories" in sklearn_args and isinstance(sklearn_args["categories"], dict):
+            # sklearn requires a list of array-like to satisfy the `categories` arg
+            try:
+                sklearn_args["categories"] = [sklearn_args["categories"][input_col] for input_col in self.input_cols]
+            except KeyError as e:
+                raise exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT,
+                    original_exception=e,
+                )
         return preprocessing.OrdinalEncoder(**sklearn_args)
 
     def _create_sklearn_object(self) -> preprocessing.OrdinalEncoder:
@@ -570,7 +598,7 @@ class OrdinalEncoder(base.BaseTransformer):
                 error_code=error_codes.INVALID_ATTRIBUTE,
                 original_exception=ValueError(f"Unsupported `categories` value: {self.categories}."),
             )
-        elif isinstance(self.categories, dict):
+        elif isinstance(self.categories, (dict, list)):
             if len(self.categories) != len(self.input_cols):
                 raise exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_ATTRIBUTE,
@@ -579,7 +607,7 @@ class OrdinalEncoder(base.BaseTransformer):
                         f"({len(self.input_cols)})."
                     ),
                 )
-            elif set(self.categories.keys()) != set(self.input_cols):
+            elif isinstance(self.categories, dict) and set(self.categories.keys()) != set(self.input_cols):
                 raise exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_ATTRIBUTE,
                     original_exception=ValueError(

snowflake/ml/modeling/preprocessing/polynomial_features.py

@@ -76,8 +76,10 @@ class PolynomialFeatures(BaseTransformer):
         initialization with the `set_input_cols` method.
     
     label_cols: Optional[Union[str, List[str]]]
-        This parameter is optional and will be ignored during fit. It is present here for API consistency by convention.
-                    
+        A string or list of strings representing column names that contain labels.
+        Label columns must be specified with this parameter during initialization
+        or with the `set_label_cols` method before fitting.
+
     output_cols: Optional[Union[str, List[str]]]
         A string or list of strings representing column names that will store the
         output of predict and transform operations. The length of output_cols must

snowflake/ml/registry/_manager/model_manager.py

@@ -4,12 +4,14 @@ from typing import Any, Dict, List, Optional, Union
 import pandas as pd
 from absl.logging import logging
 
+from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.human_readable_id import hrid_generator
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.model import model_signature, type_hints as model_types
 from snowflake.ml.model._client.model import model_impl, model_version_impl
 from snowflake.ml.model._client.ops import metadata_ops, model_ops
 from snowflake.ml.model._model_composer import model_composer
+from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.snowpark import session
 
 logger = logging.getLogger(__name__)
@@ -124,7 +126,10 @@ class ModelManager:
             version_name=version_name_id,
             statement_params=statement_params,
         ):
-            raise ValueError(f"Model {model_name} version {version_name} already existed.")
+            raise ValueError(
+                f"Model {model_name} version {version_name} already existed. "
+                + "To auto-generate `version_name`, skip that argument."
+            )
 
         stage_path = self._model_ops.prepare_model_stage_path(
             database_name=database_name_id,
@@ -134,8 +139,10 @@ class ModelManager:
 
         logger.info("Start packaging and uploading your model. It might take some time based on the size of the model.")
 
-        mc = model_composer.ModelComposer(self._model_ops._session, stage_path=stage_path)
-        mc.save(
+        mc = model_composer.ModelComposer(
+            self._model_ops._session, stage_path=stage_path, statement_params=statement_params
+        )
+        model_metadata: model_meta.ModelMetadata = mc.save(
             name=model_name_id.resolved(),
             model=model,
             signatures=signatures,
@@ -147,6 +154,12 @@ class ModelManager:
             ext_modules=ext_modules,
             options=options,
         )
+        statement_params = telemetry.add_statement_params_custom_tags(
+            statement_params, model_metadata.telemetry_metadata()
+        )
+        statement_params = telemetry.add_statement_params_custom_tags(
+            statement_params, {"model_version_name": version_name_id}
+        )
 
         logger.info("Start creating MODEL object for you in the Snowflake.")
 

snowflake/ml/registry/registry.py

@@ -1,5 +1,6 @@
+import warnings
 from types import ModuleType
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union, overload
 
 import pandas as pd
 
@@ -68,6 +69,90 @@ class Registry:
         """Get the location (database.schema) of the registry."""
         return ".".join([self._database_name.identifier(), self._schema_name.identifier()])
 
+    @overload
+    def log_model(
+        self,
+        model: model_types.SupportedModelType,
+        *,
+        model_name: str,
+        version_name: Optional[str] = None,
+        comment: Optional[str] = None,
+        metrics: Optional[Dict[str, Any]] = None,
+        conda_dependencies: Optional[List[str]] = None,
+        pip_requirements: Optional[List[str]] = None,
+        python_version: Optional[str] = None,
+        signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
+        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        code_paths: Optional[List[str]] = None,
+        ext_modules: Optional[List[ModuleType]] = None,
+        options: Optional[model_types.ModelSaveOption] = None,
+    ) -> ModelVersion:
+        """
+        Log a model with various parameters and metadata.
+
+        Args:
+            model: Model object of supported types such as Scikit-learn, XGBoost, LightGBM, Snowpark ML,
+                PyTorch, TorchScript, Tensorflow, Tensorflow Keras, MLFlow, HuggingFace Pipeline,
+                Sentence Transformers, Peft-finetuned LLM, or Custom Model.
+            model_name: Name to identify the model.
+            version_name: Version identifier for the model. Combination of model_name and version_name must be unique.
+                If not specified, a random name will be generated.
+            comment: Comment associated with the model version. Defaults to None.
+            metrics: A JSON serializable dictionary containing metrics linked to the model version. Defaults to None.
+            signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
+                sample_input_data would be used to infer the signatures for those models that cannot automatically
+                infer the signature. If not None, sample_input_data should not be specified. Defaults to None.
+            sample_input_data: Sample input data to infer model signatures from. Defaults to None.
+            conda_dependencies: List of Conda package specifications. Use "[channel::]package [operator version]" syntax
+                to specify a dependency. It is a recommended way to specify your dependencies using conda. When channel
+                is not specified, Snowflake Anaconda Channel will be used. Defaults to None.
+            pip_requirements: List of Pip package specifications. Defaults to None.
+                Currently it is not supported since Model can only executed in Snowflake Warehouse where all
+                dependencies are required to be retrieved from Snowflake Anaconda Channel.
+            python_version: Python version in which the model is run. Defaults to None.
+            code_paths: List of directories containing code to import. Defaults to None.
+            ext_modules: List of external modules to pickle with the model object.
+                Only supported when logging the following types of model:
+                Scikit-learn, Snowpark ML, PyTorch, TorchScript and Custom Model. Defaults to None.
+            options (Dict[str, Any], optional): Additional model saving options.
+                Model Saving Options include:
+                - embed_local_ml_library: Embed local Snowpark ML into the code directory or folder.
+                    Override to True if the local Snowpark ML version is not available in the Snowflake Anaconda
+                    Channel. Otherwise, defaults to False
+                - relax_version: Whether or not relax the version constraints of the dependencies.
+                    It detects any ==x.y.z in specifiers and replaced with >=x.y, <(x+1). Defaults to True.
+                - function_type: Set the method function type globally. To set method function types individually see
+                  function_type in model_options.
+                - method_options: Per-method saving options including:
+                    - case_sensitive: Indicates whether the method and its signature should be case sensitive.
+                        This means when you refer the method in the SQL, you need to double quote it.
+                        This will be helpful if you need case to tell apart your methods or features, or you have
+                        non-alphabetic characters in your method or feature name. Defaults to False.
+                    - max_batch_size: Maximum batch size that the method could accept in the Snowflake Warehouse.
+                        Defaults to None, determined automatically by Snowflake.
+                    - function_type: One of supported model method function types (FUNCTION or TABLE_FUNCTION).
+        """
+        ...
+
+    @overload
+    def log_model(
+        self,
+        model: ModelVersion,
+        *,
+        model_name: str,
+        version_name: Optional[str] = None,
+    ) -> ModelVersion:
+        """
+        Log a model with a ModelVersion object.
+
+        Args:
+            model: Source ModelVersion object used to create the new ModelVersion object.
+            model_name: Name to identify the model.
+            version_name: Version identifier for the model. Combination of model_name and version_name must be unique.
+                If not specified, a random name will be generated.
+        """
+        ...
+
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_MODEL_TELEMETRY_SUBPROJECT,
@@ -84,7 +169,7 @@ class Registry:
     )
     def log_model(
         self,
-        model: model_types.SupportedModelType,
+        model: Union[model_types.SupportedModelType, ModelVersion],
         *,
         model_name: str,
         version_name: Optional[str] = None,
@@ -100,12 +185,14 @@ class Registry:
         options: Optional[model_types.ModelSaveOption] = None,
     ) -> ModelVersion:
         """
-        Log a model with various parameters and metadata.
+        Log a model with various parameters and metadata, or a ModelVersion object.
 
         Args:
-            model: Model object of supported types such as Scikit-learn, XGBoost, LightGBM, Snowpark ML,
-                PyTorch, TorchScript, Tensorflow, Tensorflow Keras, MLFlow, HuggingFace Pipeline,
-                Sentence Transformers, Peft-finetuned LLM, or Custom Model.
+            model: Supported model or ModelVersion object.
+                - Supported model: Model object of supported types such as Scikit-learn, XGBoost, LightGBM, Snowpark ML,
+                PyTorch, TorchScript, Tensorflow, Tensorflow Keras, MLFlow, HuggingFace Pipeline, Sentence Transformers,
+                Peft-finetuned LLM, or Custom Model.
+                - ModelVersion: Source ModelVersion object used to create the new ModelVersion object.
             model_name: Name to identify the model.
             version_name: Version identifier for the model. Combination of model_name and version_name must be unique.
                 If not specified, a random name will be generated.
@@ -146,9 +233,6 @@ class Registry:
                         Defaults to None, determined automatically by Snowflake.
                     - function_type: One of supported model method function types (FUNCTION or TABLE_FUNCTION).
 
-        Raises:
-            NotImplementedError: `pip_requirements` is not supported.
-
         Returns:
             ModelVersion: ModelVersion object corresponding to the model just logged.
         """
@@ -157,10 +241,13 @@ class Registry:
             subproject=_MODEL_TELEMETRY_SUBPROJECT,
         )
         if pip_requirements:
-            raise NotImplementedError(
-                "Currently `pip_requirements` is not supported since Model can only executed "
+            warnings.warn(
+                "Models logged specifying `pip_requirements` can not be executed "
                 "in Snowflake Warehouse where all dependencies are required to be retrieved "
-                "from Snowflake Anaconda Channel."
+                "from Snowflake Anaconda Channel. Specify model save option `include_pip_dependencies`"
+                "to log model with pip dependencies.",
+                category=UserWarning,
+                stacklevel=1,
             )
         return self._model_manager.log_model(
             model=model,
@@ -169,7 +256,7 @@ class Registry:
             comment=comment,
             metrics=metrics,
             conda_dependencies=conda_dependencies,
-            pip_requirements=None,
+            pip_requirements=pip_requirements,
             python_version=python_version,
             signatures=signatures,
             sample_input_data=sample_input_data,

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.5.3"
+VERSION="1.6.0"

{snowflake_ml_python-1.5.3.dist-info → snowflake_ml_python-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-ml-python
-Version: 1.5.3
+Version: 1.6.0
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -250,7 +250,7 @@ Requires-Dist: s3fs <2024,>=2022.11
 Requires-Dist: scikit-learn <1.4,>=1.2.1
 Requires-Dist: scipy <2,>=1.9
 Requires-Dist: snowflake-connector-python[pandas] <4,>=3.5.0
-Requires-Dist: snowflake-snowpark-python <2,>=1.15.0
+Requires-Dist: snowflake-snowpark-python <2,>=1.17.0
 Requires-Dist: sqlparse <1,>=0.4
 Requires-Dist: typing-extensions <5,>=4.1.0
 Requires-Dist: xgboost <2,>=1.7.3
@@ -264,7 +264,7 @@ Requires-Dist: sentencepiece <1,>=0.1.95 ; extra == 'all'
 Requires-Dist: shap ==0.42.1 ; extra == 'all'
 Requires-Dist: tensorflow <3,>=2.10 ; extra == 'all'
 Requires-Dist: tokenizers <1,>=0.10 ; extra == 'all'
-Requires-Dist: torch <3,>=2.0.1 ; extra == 'all'
+Requires-Dist: torch <2.3.0,>=2.0.1 ; extra == 'all'
 Requires-Dist: torchdata <1,>=0.4 ; extra == 'all'
 Requires-Dist: transformers <5,>=4.32.1 ; extra == 'all'
 Provides-Extra: catboost
@@ -280,7 +280,7 @@ Requires-Dist: shap ==0.42.1 ; extra == 'shap'
 Provides-Extra: tensorflow
 Requires-Dist: tensorflow <3,>=2.10 ; extra == 'tensorflow'
 Provides-Extra: torch
-Requires-Dist: torch <3,>=2.0.1 ; extra == 'torch'
+Requires-Dist: torch <2.3.0,>=2.0.1 ; extra == 'torch'
 Requires-Dist: torchdata <1,>=0.4 ; extra == 'torch'
 Provides-Extra: transformers
 Requires-Dist: sentence-transformers <3,>=2.2.2 ; extra == 'transformers'
@@ -373,7 +373,83 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 # Release History
 
-## 1.5.3
+## 1.6.0
+
+### Bug Fixes
+
+- Modeling: `SimpleImputer` can impute integer columns with integer values.
+- Registry: Fix an issue when providing a pandas Dataframe whose index is not starting from 0 as the input to
+  the `ModelVersion.run`.
+
+### New Features
+
+- Feature Store: Add overloads to APIs accept both object and name/version. Impacted APIs include read_feature_view(),
+  refresh_feature_view(), get_refresh_history(), resume_feature_view(), suspend_feature_view(), delete_feature_view().
+- Feature Store: Add docstring inline examples for all public APIs.
+- Feature Store: Add new utility class `ExampleHelper` to help with load source data to simplify public notebooks.
+- Registry: Option to `enable_explainability` when registering XGBoost models as a pre-PuPr feature.
+- Feature Store: add new API `update_entity()`.
+- Registry: Option to `enable_explainability` when registering Catboost models as a pre-PuPr feature.
+- Feature Store: Add new argument warehouse to FeatureView constructor to overwrite the default warehouse. Also add
+  a new column 'warehouse' to the output of list_feature_views().
+- Registry: Add support for logging model from a model version.
+- Modeling: Distributed Hyperparameter Optimization now announce GA refresh version. The latest memory efficient version
+  will not have the 10GB training limitation for dataset any more. To turn off, please run
+  `
+  from snowflake.ml.modeling._internal.snowpark_implementations import (
+      distributed_hpo_trainer,
+  )
+  distributed_hpo_trainer.ENABLE_EFFICIENT_MEMORY_USAGE = False
+  `
+- Registry: Option to `enable_explainability` when registering LightGBM models as a pre-PuPr feature.
+
+### Behavior Changes
+
+- Feature Store: change some positional parameters to keyword arguments in following APIs:
+  - Entity(): desc.
+  - FeatureView(): timestamp_col, refresh_freq, desc.
+  - FeatureStore(): creation_mode.
+  - update_entity(): desc.
+  - register_feature_view(): block, overwrite.
+  - list_feature_views(): entity_name, feature_view_name.
+  - get_refresh_history(): verbose.
+  - retrieve_feature_values(): spine_timestamp_col, exclude_columns, include_feature_view_timestamp_col.
+  - generate_training_set(): save_as, spine_timestamp_col, spine_label_cols, exclude_columns,
+    include_feature_view_timestamp_col.
+  - generate_dataset(): version, spine_timestamp_col, spine_label_cols, exclude_columns,
+    include_feature_view_timestamp_col, desc, output_type.
+
+## 1.5.4 (2024-07-11)
+
+### Bug Fixes
+
+- Model Registry (PrPr): Fix 401 Unauthorized issue when deploying model to SPCS.
+- Feature Store: Downgrades exceptions to warnings for few property setters in feature view. Now you can set
+  desc, refresh_freq and warehouse for draft feature views.
+- Modeling: Fix an issue with calling `OrdinalEncoder` with `categories` as a dictionary and a pandas DataFrame
+- Modeling: Fix an issue with calling `OneHotEncoder` with `categories` as a dictionary and a pandas DataFrame
+
+### New Features
+
+- Registry: Allow overriding `device_map` and `device` when loading huggingface pipeline models.
+- Registry: Add `set_alias` method to `ModelVersion` instance to set an alias to model version.
+- Registry: Add `unset_alias` method to `ModelVersion` instance to unset an alias to model version.
+- Registry: Add `partitioned_inference_api` allowing users to create partitioned inference functions in registered
+  models. Enable model inference methods with table functions with vectorized process methods in registered models.
+- Feature Store: add 3 more columns: refresh_freq, refresh_mode and scheduling_state to the result of
+  `list_feature_views()`.
+- Feature Store: `update_feature_view()` supports updating description.
+- Feature Store: add new API `refresh_feature_view()`.
+- Feature Store: add new API `get_refresh_history()`.
+- Feature Store: Add `generate_training_set()` API for generating table-backed feature snapshots.
+- Feature Store: Add `DeprecationWarning` for `generate_dataset(..., output_type="table")`.
+- Feature Store: `update_feature_view()` supports updating description.
+- Feature Store: add new API `refresh_feature_view()`.
+- Feature Store: add new API `get_refresh_history()`.
+- Model Development: OrdinalEncoder supports a list of array-likes for `categories` argument.
+- Model Development: OneHotEncoder supports a list of array-likes for `categories` argument.
+
+## 1.5.3 (06-17-2024)
 
 ### Bug Fixes
 
@@ -382,8 +458,6 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 - Registry: Fix an issue that leads to incorrect result when using pandas Dataframe with over 100, 000 rows as the input
   of `ModelVersion.run` method in Stored Procedure.
 
-### Behavior Changes
-
 ### New Features
 
 - Registry: Add support for TIMESTAMP_NTZ model signature data type, allowing timestamp input and output.