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

snowflake/ml/modeling/svm/linear_svc.py

@@ -655,7 +655,14 @@ class LinearSVC(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/svm/linear_svr.py

@@ -627,7 +627,14 @@ class LinearSVR(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/svm/nu_svc.py

@@ -661,7 +661,14 @@ class NuSVC(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/svm/nu_svr.py

@@ -622,7 +622,14 @@ class NuSVR(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/svm/svc.py

@@ -664,7 +664,14 @@ class SVC(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/svm/svr.py

@@ -625,7 +625,14 @@ class SVR(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/tree/decision_tree_classifier.py

@@ -692,7 +692,14 @@ class DecisionTreeClassifier(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/tree/decision_tree_regressor.py

@@ -674,7 +674,14 @@ class DecisionTreeRegressor(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/tree/extra_tree_classifier.py

@@ -684,7 +684,14 @@ class ExtraTreeClassifier(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/tree/extra_tree_regressor.py

@@ -666,7 +666,14 @@ class ExtraTreeRegressor(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/xgboost/xgb_classifier.py

@@ -784,7 +784,14 @@ class XGBClassifier(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/xgboost/xgb_regressor.py

@@ -783,7 +783,14 @@ class XGBRegressor(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/xgboost/xgbrf_classifier.py

@@ -788,7 +788,14 @@ class XGBRFClassifier(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/modeling/xgboost/xgbrf_regressor.py

@@ -788,7 +788,14 @@ class XGBRFRegressor(BaseTransformer):
     ) -> List[str]:
         # in case the inferred output column names dimension is different 
         # we use one line of snowpark dataframe and put it into sklearn estimator using pandas
-        output_df_pd = getattr(self, method)(dataset.limit(1).to_pandas(), output_cols_prefix)
+        sample_pd_df = dataset.select(self.input_cols).limit(1).to_pandas()
+
+        # Rename the pandas df column names to snowflake identifiers and reorder columns to match the order
+        # seen during the fit.
+        snowpark_column_names = dataset.select(self.input_cols).columns
+        sample_pd_df.columns = snowpark_column_names
+
+        output_df_pd = getattr(self, method)(sample_pd_df, output_cols_prefix)
         output_df_columns = list(output_df_pd.columns)
         output_df_columns_set: Set[str] = set(output_df_columns) - set(dataset.columns)
         if self.sample_weight_col:

snowflake/ml/registry/_manager/model_manager.py

@@ -1,5 +1,5 @@
 from types import ModuleType
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import pandas as pd
 from absl.logging import logging
@@ -31,6 +31,64 @@ class ModelManager:
         self._hrid_generator = hrid_generator.HRID16()
 
     def log_model(
+        self,
+        *,
+        model: Union[model_types.SupportedModelType, model_version_impl.ModelVersion],
+        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,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> model_version_impl.ModelVersion:
+        if not version_name:
+            version_name = self._hrid_generator.generate()[1]
+
+        if isinstance(model, model_version_impl.ModelVersion):
+            (
+                source_database_name_id,
+                source_schema_name_id,
+                source_model_name_id,
+            ) = sql_identifier.parse_fully_qualified_name(model.fully_qualified_model_name)
+
+            self._model_ops.create_from_model_version(
+                source_database_name=source_database_name_id,
+                source_schema_name=source_schema_name_id,
+                source_model_name=source_model_name_id,
+                source_version_name=sql_identifier.SqlIdentifier(model.version_name),
+                database_name=None,
+                schema_name=None,
+                model_name=sql_identifier.SqlIdentifier(model_name),
+                version_name=sql_identifier.SqlIdentifier(version_name),
+                statement_params=statement_params,
+            )
+            return self.get_model(model_name=model_name, statement_params=statement_params).version(version_name)
+
+        return self._log_model(
+            model=model,
+            model_name=model_name,
+            version_name=version_name,
+            comment=comment,
+            metrics=metrics,
+            conda_dependencies=conda_dependencies,
+            pip_requirements=pip_requirements,
+            python_version=python_version,
+            signatures=signatures,
+            sample_input_data=sample_input_data,
+            code_paths=code_paths,
+            ext_modules=ext_modules,
+            options=options,
+            statement_params=statement_params,
+        )
+
+    def _log_model(
         self,
         model: model_types.SupportedModelType,
         *,
@@ -48,20 +106,29 @@ class ModelManager:
         options: Optional[model_types.ModelSaveOption] = None,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> model_version_impl.ModelVersion:
-        model_name_id = sql_identifier.SqlIdentifier(model_name)
+        database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
 
         if not version_name:
             version_name = self._hrid_generator.generate()[1]
         version_name_id = sql_identifier.SqlIdentifier(version_name)
 
         if self._model_ops.validate_existence(
-            model_name=model_name_id, statement_params=statement_params
+            database_name=database_name_id,
+            schema_name=schema_name_id,
+            model_name=model_name_id,
+            statement_params=statement_params,
         ) and self._model_ops.validate_existence(
-            model_name=model_name_id, version_name=version_name_id, statement_params=statement_params
+            database_name=database_name_id,
+            schema_name=schema_name_id,
+            model_name=model_name_id,
+            version_name=version_name_id,
+            statement_params=statement_params,
         ):
             raise ValueError(f"Model {model_name} version {version_name} already existed.")
 
         stage_path = self._model_ops.prepare_model_stage_path(
+            database_name=database_name_id,
+            schema_name=schema_name_id,
             statement_params=statement_params,
         )
 
@@ -85,13 +152,19 @@ class ModelManager:
 
         self._model_ops.create_from_stage(
             composed_model=mc,
+            database_name=database_name_id,
+            schema_name=schema_name_id,
             model_name=model_name_id,
             version_name=version_name_id,
             statement_params=statement_params,
         )
 
         mv = model_version_impl.ModelVersion._ref(
-            self._model_ops,
+            model_ops.ModelOperator(
+                self._model_ops._session,
+                database_name=database_name_id or self._database_name,
+                schema_name=schema_name_id or self._schema_name,
+            ),
             model_name=model_name_id,
             version_name=version_name_id,
         )
@@ -102,6 +175,8 @@ class ModelManager:
         if metrics:
             self._model_ops._metadata_ops.save(
                 metadata_ops.ModelVersionMetadataSchema(metrics=metrics),
+                database_name=database_name_id,
+                schema_name=schema_name_id,
                 model_name=model_name_id,
                 version_name=version_name_id,
                 statement_params=statement_params,
@@ -115,13 +190,19 @@ class ModelManager:
         *,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> model_impl.Model:
-        model_name_id = sql_identifier.SqlIdentifier(model_name)
+        database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
         if self._model_ops.validate_existence(
+            database_name=database_name_id,
+            schema_name=schema_name_id,
             model_name=model_name_id,
             statement_params=statement_params,
         ):
             return model_impl.Model._ref(
-                self._model_ops,
+                model_ops.ModelOperator(
+                    self._model_ops._session,
+                    database_name=database_name_id or self._database_name,
+                    schema_name=schema_name_id or self._schema_name,
+                ),
                 model_name=model_name_id,
             )
         else:
@@ -133,6 +214,8 @@ class ModelManager:
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> List[model_impl.Model]:
         model_names = self._model_ops.list_models_or_versions(
+            database_name=None,
+            schema_name=None,
             statement_params=statement_params,
         )
         return [
@@ -149,6 +232,8 @@ class ModelManager:
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> pd.DataFrame:
         rows = self._model_ops.show_models_or_versions(
+            database_name=None,
+            schema_name=None,
             statement_params=statement_params,
         )
         return pd.DataFrame([row.as_dict() for row in rows])
@@ -159,9 +244,11 @@ class ModelManager:
         *,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> None:
-        model_name_id = sql_identifier.SqlIdentifier(model_name)
+        database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
 
         self._model_ops.delete_model_or_version(
+            database_name=database_name_id,
+            schema_name=schema_name_id,
             model_name=model_name_id,
             statement_params=statement_params,
         )

snowflake/ml/registry/registry.py

@@ -71,6 +71,16 @@ class Registry:
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_MODEL_TELEMETRY_SUBPROJECT,
+        func_params_to_log=[
+            "model_name",
+            "version_name",
+            "comment",
+            "metrics",
+            "conda_dependencies",
+            "pip_requirements",
+            "python_version",
+            "signatures",
+        ],
     )
     def log_model(
         self,
@@ -142,7 +152,6 @@ class Registry:
         Returns:
             ModelVersion: ModelVersion object corresponding to the model just logged.
         """
-
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
             subproject=_MODEL_TELEMETRY_SUBPROJECT,

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.5.0"
+VERSION="1.5.2"

{snowflake_ml_python-1.5.0.dist-info → snowflake_ml_python-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-ml-python
-Version: 1.5.0
+Version: 1.5.2
 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: 
@@ -236,7 +236,6 @@ License-File: LICENSE.txt
 Requires-Dist: absl-py <2,>=0.15
 Requires-Dist: anyio <4,>=3.5.0
 Requires-Dist: cachetools <6,>=3.1.1
-Requires-Dist: catboost <1.3,>=1.2.0
 Requires-Dist: cloudpickle >=2.0.0
 Requires-Dist: fsspec[http] <2024,>=2022.11
 Requires-Dist: importlib-resources <7,>=6.1.1
@@ -256,19 +255,22 @@ Requires-Dist: sqlparse <1,>=0.4
 Requires-Dist: typing-extensions <5,>=4.1.0
 Requires-Dist: xgboost <2,>=1.7.3
 Provides-Extra: all
-Requires-Dist: lightgbm <4.2,>=3.3.5 ; extra == 'all'
+Requires-Dist: catboost <2,>=1.2.0 ; extra == 'all'
+Requires-Dist: lightgbm <5,>=3.3.5 ; extra == 'all'
 Requires-Dist: mlflow <2.4,>=2.1.0 ; extra == 'all'
 Requires-Dist: peft <1,>=0.5.0 ; extra == 'all'
 Requires-Dist: sentence-transformers <3,>=2.2.2 ; extra == 'all'
-Requires-Dist: sentencepiece <0.2,>=0.1.95 ; extra == 'all'
+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: torchdata <1,>=0.4 ; extra == 'all'
 Requires-Dist: transformers <5,>=4.32.1 ; extra == 'all'
+Provides-Extra: catboost
+Requires-Dist: catboost <2,>=1.2.0 ; extra == 'catboost'
 Provides-Extra: lightgbm
-Requires-Dist: lightgbm <4.2,>=3.3.5 ; extra == 'lightgbm'
+Requires-Dist: lightgbm <5,>=3.3.5 ; extra == 'lightgbm'
 Provides-Extra: llm
 Requires-Dist: peft <1,>=0.5.0 ; extra == 'llm'
 Provides-Extra: mlflow
@@ -282,7 +284,7 @@ Requires-Dist: torch <3,>=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'
-Requires-Dist: sentencepiece <0.2,>=0.1.95 ; extra == 'transformers'
+Requires-Dist: sentencepiece <1,>=0.1.95 ; extra == 'transformers'
 Requires-Dist: tokenizers <1,>=0.10 ; extra == 'transformers'
 Requires-Dist: transformers <5,>=4.32.1 ; extra == 'transformers'
 
@@ -371,6 +373,43 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 # Release History
 
+## 1.5.2
+
+### Bug Fixes
+
+- Registry: Fix an issue that leads to unable to log model in store procedure.
+- Modeling: Quick fix `import snowflake.ml.modeling.parameters.enable_anonymous_sproc` cannot be imported due to package
+  dependency error.
+
+### Behavior Changes
+
+### New Features
+
+## 1.5.1
+
+### Bug Fixes
+
+- Dataset: Fix `snowflake.connector.errors.DataError: Query Result did not match expected number of rows` when accessing
+  DatasetVersion properties when case insensitive `SHOW VERSIONS IN DATASET` check matches multiple version names.
+- Dataset: Fix bug in SnowFS bulk file read when used with DuckDB
+- Registry: Fixed a bug when loading old models.
+- Lineage: Fix Dataset source lineage propagation through `snowpark.DataFrame` transformations
+
+### Behavior Changes
+
+- Feature Store: convert clear() into a private function. Also make it deletes feature views and entities only.
+- Feature Store: Use NULL as default value for timestamp tag value.
+
+### New Features
+
+- Feature Store: Added new `snowflake.ml.feature_store.setup_feature_store()` API to assist Feature Store RBAC setup.
+- Feature Store: Add `output_type` argument to `FeatureStore.generate_dataset()` to allow generating data snapshots
+  as Datasets or Tables.
+- Registry: `log_model`, `get_model`, `delete_model` now supports fully qualified name.
+- Modeling: Supports anonymous stored procedure during fit calls so that modeling would not require sufficient
+  permissions to operate on schema. Please call
+  `import snowflake.ml.modeling.parameters.enable_anonymous_sproc  # noqa: F401`
+
 ## 1.5.0
 
 ### Bug Fixes
@@ -411,12 +450,19 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 #### Feature Store (PrPr)
 
-`FeatureStore.generate_dataset` argument list has been changed to match the new
+- `FeatureStore.generate_dataset` argument list has been changed to match the new
 `snowflake.ml.dataset.Dataset` definition
 
-- `materialized_table` has been removed and replaced with `name` and `version`.
-- `name` moved to first positional argument
-- `save_mode` has been removed as `merge` behavior is no longer supported. The new behavior is always `errorifexists`.
+  - `materialized_table` has been removed and replaced with `name` and `version`.
+  - `name` moved to first positional argument
+  - `save_mode` has been removed as `merge` behavior is no longer supported. The new behavior is always `errorifexists`.
+
+- Change feature view version type from str to `FeatureViewVersion`. It is a restricted string literal.
+
+- Remove as_dataframe arg from FeatureStore.list_feature_views(), now always returns result as DataFrame.
+
+- Combines few metadata tags into a new tag: SNOWML_FEATURE_VIEW_METADATA. This will make previously created feature views
+not readable by new SDK.
 
 ### New Features
 
@@ -432,6 +478,10 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
     and `Dataset.read.to_tf_dataset()` respectively.
 - Added `fsspec` style file integration using `Dataset.read.files()` and `Dataset.read.filesystem()`
 
+#### Feature Store
+
+- use new tag_reference_internal to speed up metadata lookup.
+
 ## 1.4.1 (2024-04-18)
 
 ### New Features
@@ -443,6 +493,10 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 - Registry: Fix a bug that leads to relax_version option is not working.
 
+### Behavior changes
+
+- Feature Store: update_feature_view takes refresh_freq and warehouse as argument.
+
 ## 1.4.0 (2024-04-08)
 
 ### Bug Fixes
@@ -464,6 +518,8 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 - Registry: `apply` method is no longer by default logged when logging a xgboost model. If that is required, it could
   be specified manually when logging the model by `log_model(..., options={"target_methods": ["apply", ...]})`.
+- Feature Store: register_entity returns an entity object.
+- Feature Store: register_feature_view `block=true` becomes default.
 
 ### New Features