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

snowflake/ml/monitoring/_client/queries/record_count.ssql

@@ -0,0 +1,14 @@
+CREATE OR REPLACE FUNCTION ${MODEL_MONITOR_NAME}_PREDICTION_COUNT()
+    RETURNS TABLE(event_timestamp TIMESTAMP_NTZ, count FLOAT)
+    AS
+    $$$$
+SELECT
+    time_slice(timestamp, 1, 'hour') as "event_timestamp",
+    sum(get($OUTPUT_COLUMN_NAME,'count')) as count
+from
+    $MONITORING_TABLE
+group by
+    1
+order by
+    1 desc
+    $$$$;

snowflake/ml/monitoring/_client/queries/rmse.ssql

@@ -0,0 +1,28 @@
+CREATE OR REPLACE FUNCTION ${MODEL_MONITOR_NAME}_RMSE()
+    RETURNS TABLE(event_timestamp TIMESTAMP_NTZ, value FLOAT)
+    AS
+$$$$
+WITH metric_of_interest as (
+    select
+    time_slice(timestamp, 1, 'hour') as event_timestamp,
+    AGGREGATE_METRICS:"sum_difference_squares_label_pred" as aggregate_field,
+    AGGREGATE_METRICS:"count" as "count"
+    from
+        $MONITORING_PRED_LABEL_JOINED_TABLE
+), metric_combine as (
+    select
+        event_timestamp,
+        CAST(SUM(NVL(aggregate_field, 0)) as DOUBLE) as metric_sum,
+        SUM("count") as metric_count
+    from
+        metric_of_interest
+    where
+        cast(aggregate_field as varchar) not in ('inf','-inf','NaN')
+    group by
+        1
+) select
+    event_timestamp,
+    SQRT(DIV0(metric_sum,metric_count)) as VALUE
+from metric_combine
+order by 1 desc
+$$$$;

snowflake/ml/monitoring/entities/model_monitor_config.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from typing import List
+
+from snowflake.ml.model._client.model import model_version_impl
+from snowflake.ml.monitoring.entities import model_monitor_interval
+
+
+@dataclass
+class ModelMonitorTableConfig:
+    source_table: str
+    timestamp_column: str
+    prediction_columns: List[str]
+    label_columns: List[str]
+    id_columns: List[str]
+
+
+@dataclass
+class ModelMonitorConfig:
+    model_version: model_version_impl.ModelVersion
+
+    # Python model function name
+    model_function_name: str
+    background_compute_warehouse_name: str
+    # TODO: Add support for pythonic notion of time.
+    refresh_interval: str = model_monitor_interval.ModelMonitorRefreshInterval.DAILY
+    aggregation_window: model_monitor_interval.ModelMonitorAggregationWindow = (
+        model_monitor_interval.ModelMonitorAggregationWindow.WINDOW_1_DAY
+    )

snowflake/ml/monitoring/entities/model_monitor_interval.py

@@ -0,0 +1,46 @@
+from enum import Enum
+
+
+class ModelMonitorAggregationWindow(Enum):
+    WINDOW_1_HOUR = 60
+    WINDOW_1_DAY = 24 * 60
+
+    def __init__(self, minutes: int) -> None:
+        super().__init__()
+        self.minutes = minutes
+
+
+class ModelMonitorRefreshInterval:
+    EVERY_30_MINUTES = "30 minutes"
+    HOURLY = "1 hours"
+    EVERY_6_HOURS = "6 hours"
+    EVERY_12_HOURS = "12 hours"
+    DAILY = "1 days"
+    WEEKLY = "7 days"
+    BIWEEKLY = "14 days"
+    MONTHLY = "30 days"
+
+    _ALLOWED_TIME_UNITS = {"minutes": 1, "hours": 60, "days": 24 * 60}
+
+    def __init__(self, raw_time_str: str) -> None:
+        try:
+            num_units_raw, time_units = raw_time_str.strip().split(" ")
+            num_units = int(num_units_raw)  # try to cast
+        except Exception as e:
+            raise ValueError(
+                f"""Failed to parse refresh interval with exception {e}.
+                Provide '<num> <minutes | hours | days>'.
+See https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table#required-parameters for more info."""
+            )
+        if time_units.lower() not in self._ALLOWED_TIME_UNITS:
+            raise ValueError(
+                """Invalid time unit in refresh interval. Provide '<num> <minutes | hours | days>'.
+See https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table#required-parameters for more info."""
+            )
+        minutes_multiplier = self._ALLOWED_TIME_UNITS[time_units.lower()]
+        self.minutes = num_units * minutes_multiplier
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, ModelMonitorRefreshInterval):
+            return False
+        return self.minutes == value.minutes

snowflake/ml/monitoring/entities/output_score_type.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import List, Mapping
+
+from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml.model import type_hints
+from snowflake.snowpark import types
+
+# Accepted data types for each OutputScoreType.
+REGRESSION_DATA_TYPES = (
+    types.ByteType,
+    types.ShortType,
+    types.IntegerType,
+    types.LongType,
+    types.FloatType,
+    types.DoubleType,
+    types.DecimalType,
+)
+CLASSIFICATION_DATA_TYPES = (
+    types.ByteType,
+    types.ShortType,
+    types.IntegerType,
+    types.BooleanType,
+    types.BinaryType,
+)
+PROBITS_DATA_TYPES = (
+    types.ByteType,
+    types.ShortType,
+    types.IntegerType,
+    types.LongType,
+    types.FloatType,
+    types.DoubleType,
+    types.DecimalType,
+)
+
+
+# OutputScoreType enum
+class OutputScoreType(Enum):
+    UNKNOWN = "UNKNOWN"
+    REGRESSION = "REGRESSION"
+    CLASSIFICATION = "CLASSIFICATION"
+    PROBITS = "PROBITS"
+
+    @classmethod
+    def deduce_score_type(
+        cls,
+        table_schema: Mapping[str, types.DataType],
+        prediction_columns: List[sql_identifier.SqlIdentifier],
+        task: type_hints.Task,
+    ) -> OutputScoreType:
+        """Find the score type for monitoring given a table schema and the task.
+
+        Args:
+            table_schema: Dictionary of column names and types in the source table.
+            prediction_columns: List of prediction columns.
+            task: Enum value for the task of the model.
+
+        Returns:
+            Enum value for the score type, informing monitoring table set up.
+
+        Raises:
+            ValueError: If prediction type fails to align with task.
+        """
+        # Already validated we have just one prediction column type
+        prediction_column_type = {table_schema[column_name] for column_name in prediction_columns}.pop()
+
+        if task == type_hints.Task.TABULAR_REGRESSION:
+            if isinstance(prediction_column_type, REGRESSION_DATA_TYPES):
+                return OutputScoreType.REGRESSION
+            else:
+                raise ValueError(
+                    f"Expected prediction column type to be one of {REGRESSION_DATA_TYPES} "
+                    f"for REGRESSION task. Found: {prediction_column_type}."
+                )
+
+        elif task == type_hints.Task.TABULAR_BINARY_CLASSIFICATION:
+            if isinstance(prediction_column_type, CLASSIFICATION_DATA_TYPES):
+                return OutputScoreType.CLASSIFICATION
+            elif isinstance(prediction_column_type, PROBITS_DATA_TYPES):
+                return OutputScoreType.PROBITS
+            else:
+                raise ValueError(
+                    f"Expected prediction column type to be one of {CLASSIFICATION_DATA_TYPES} "
+                    f"or one of {PROBITS_DATA_TYPES} for CLASSIFICATION task. "
+                    f"Found: {prediction_column_type}."
+                )
+
+        else:
+            raise ValueError(f"Received unsupported task for model monitoring: {task}.")

snowflake/ml/registry/_manager/model_manager.py

@@ -50,6 +50,7 @@ class ModelManager:
         sample_input_data: Optional[model_types.SupportedDataType] = None,
         code_paths: Optional[List[str]] = None,
         ext_modules: Optional[List[ModuleType]] = None,
+        task: model_types.Task = model_types.Task.UNKNOWN,
         options: Optional[model_types.ModelSaveOption] = None,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> model_version_impl.ModelVersion:
@@ -89,6 +90,7 @@ class ModelManager:
             sample_input_data=sample_input_data,
             code_paths=code_paths,
             ext_modules=ext_modules,
+            task=task,
             options=options,
             statement_params=statement_params,
         )
@@ -108,6 +110,7 @@ class ModelManager:
         sample_input_data: Optional[model_types.SupportedDataType] = None,
         code_paths: Optional[List[str]] = None,
         ext_modules: Optional[List[ModuleType]] = None,
+        task: model_types.Task = model_types.Task.UNKNOWN,
         options: Optional[model_types.ModelSaveOption] = None,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> model_version_impl.ModelVersion:
@@ -156,6 +159,7 @@ class ModelManager:
             code_paths=code_paths,
             ext_modules=ext_modules,
             options=options,
+            task=task,
         )
         statement_params = telemetry.add_statement_params_custom_tags(
             statement_params, model_metadata.telemetry_metadata()

snowflake/ml/registry/registry.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Union, overload
 
 import pandas as pd
 
+from snowflake import snowpark
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.model import (
@@ -12,6 +13,13 @@ from snowflake.ml.model import (
     model_signature,
     type_hints as model_types,
 )
+from snowflake.ml.model._client.model import model_version_impl
+from snowflake.ml.monitoring._client import (
+    model_monitor,
+    model_monitor_manager,
+    model_monitor_version,
+)
+from snowflake.ml.monitoring.entities import model_monitor_config
 from snowflake.ml.registry._manager import model_manager
 from snowflake.snowpark import session
 
@@ -26,6 +34,7 @@ class Registry:
         *,
         database_name: Optional[str] = None,
         schema_name: Optional[str] = None,
+        options: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Opens a registry within a pre-created Snowflake schema.
 
@@ -35,6 +44,9 @@ class Registry:
                 will be used. Defaults to None.
             schema_name: The name of the schema. If None, the current schema of the session
                 will be used. If there is no active schema, the PUBLIC schema will be used. Defaults to None.
+            options: Optional set of configurations to modify registry.
+                Registry Options include:
+                - enable_monitoring: Feature flag to indicate whether registry can be used for monitoring.
 
         Raises:
             ValueError: When there is no specified or active database in the session.
@@ -64,6 +76,21 @@ class Registry:
             session, database_name=self._database_name, schema_name=self._schema_name
         )
 
+        self.enable_monitoring = options.get("enable_monitoring", False) if options else False
+        if self.enable_monitoring:
+            monitor_statement_params = telemetry.get_statement_params(
+                project=telemetry.TelemetryProject.MLOPS.value,
+                subproject=telemetry.TelemetrySubProject.MONITORING.value,
+            )
+
+            self._model_monitor_manager = model_monitor_manager.ModelMonitorManager(
+                session=session,
+                database_name=self._database_name,
+                schema_name=self._schema_name,
+                create_if_not_exists=True,  # TODO: Support static setup method to configure schema for monitoring.
+                statement_params=monitor_statement_params,
+            )
+
     @property
     def location(self) -> str:
         """Get the location (database.schema) of the registry."""
@@ -93,7 +120,7 @@ class Registry:
         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.
+                Sentence Transformers, 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.
@@ -119,8 +146,8 @@ class Registry:
                 - 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.
+                - relax_version: Whether or not relax the version constraints of the dependencies when running in the
+                    Warehouse. 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:
@@ -182,6 +209,7 @@ class Registry:
         sample_input_data: Optional[model_types.SupportedDataType] = None,
         code_paths: Optional[List[str]] = None,
         ext_modules: Optional[List[ModuleType]] = None,
+        task: model_types.Task = model_types.Task.UNKNOWN,
         options: Optional[model_types.ModelSaveOption] = None,
     ) -> ModelVersion:
         """
@@ -191,7 +219,7 @@ class Registry:
             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.
+                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.
@@ -213,6 +241,9 @@ class Registry:
             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.
+            task: The task of the Model Version. It is an enum class Task with values TABULAR_REGRESSION,
+                TABULAR_BINARY_CLASSIFICATION, TABULAR_MULTI_CLASSIFICATION, TABULAR_RANKING, or UNKNOWN. By default,
+                it is set to Task.UNKNOWN and may be overridden by inferring from the Model Object.
             options (Dict[str, Any], optional): Additional model saving options.
 
                 Model Saving Options include:
@@ -220,8 +251,8 @@ class Registry:
                 - 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.
+                - relax_version: Whether or not relax the version constraints of the dependencies when running in the
+                    Warehouse. 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:
@@ -244,8 +275,7 @@ class Registry:
             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. Specify model save option `include_pip_dependencies`"
-                "to log model with pip dependencies.",
+                "from Snowflake Anaconda Channel.",
                 category=UserWarning,
                 stacklevel=1,
             )
@@ -262,6 +292,7 @@ class Registry:
             sample_input_data=sample_input_data,
             code_paths=code_paths,
             ext_modules=ext_modules,
+            task=task,
             options=options,
             statement_params=statement_params,
         )
@@ -334,3 +365,130 @@ class Registry:
         )
 
         self._model_manager.delete_model(model_name=model_name, statement_params=statement_params)
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
+    def add_monitor(
+        self,
+        name: str,
+        table_config: model_monitor_config.ModelMonitorTableConfig,
+        model_monitor_config: model_monitor_config.ModelMonitorConfig,
+        *,
+        add_dashboard_udtfs: bool = False,
+    ) -> model_monitor.ModelMonitor:
+        """Add a Model Monitor to the Registry
+
+        Args:
+            name: Name of Model Monitor to create
+            table_config: Configuration options of table for ModelMonitor.
+            model_monitor_config: Configuration options of ModelMonitor.
+            add_dashboard_udtfs: Add UDTFs useful for creating a dashboard.
+
+        Returns:
+            The newly added ModelMonitor object.
+
+        Raises:
+            ValueError: If monitoring feature flag is not enabled.
+        """
+        if not self.enable_monitoring:
+            raise ValueError(
+                "Must enable monitoring in Registry to use this method. Please set the `enable_monitoring=True` option"
+            )
+
+        # TODO: Change to fully qualified source table reference to allow table to live in different DB.
+        return self._model_monitor_manager.add_monitor(
+            name, table_config, model_monitor_config, add_dashboard_udtfs=add_dashboard_udtfs
+        )
+
+    @overload
+    def get_monitor(self, model_version: model_version_impl.ModelVersion) -> model_monitor.ModelMonitor:
+        """Get a Model Monitor on a ModelVersion from the Registry
+
+        Args:
+            model_version: ModelVersion for which to retrieve the ModelMonitor.
+        """
+        ...
+
+    @overload
+    def get_monitor(self, name: str) -> model_monitor.ModelMonitor:
+        """Get a Model Monitor from the Registry
+
+        Args:
+            name: Name of Model Monitor to retrieve.
+        """
+        ...
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
+    def get_monitor(
+        self, *, name: Optional[str] = None, model_version: Optional[model_version_impl.ModelVersion] = None
+    ) -> model_monitor.ModelMonitor:
+        """Get a Model Monitor from the Registry
+
+        Args:
+            name: Name of Model Monitor to retrieve.
+            model_version: ModelVersion for which to retrieve the ModelMonitor.
+
+        Returns:
+            The fetched ModelMonitor.
+
+        Raises:
+            ValueError: If monitoring feature flag is not enabled.
+            ValueError: If neither name nor model_version specified.
+        """
+        if not self.enable_monitoring:
+            raise ValueError(
+                "Must enable monitoring in Registry to use this method. Please set the `enable_monitoring=True` option"
+            )
+        if name is not None:
+            return self._model_monitor_manager.get_monitor(name=name)
+        elif model_version is not None:
+            return self._model_monitor_manager.get_monitor_by_model_version(model_version=model_version)
+        else:
+            raise ValueError("Must provide either `name` or `model_version` to get ModelMonitor")
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
+    def show_model_monitors(self) -> List[snowpark.Row]:
+        """Show all model monitors in the registry.
+
+        Returns:
+            List of snowpark.Row containing metadata for each model monitor.
+
+        Raises:
+            ValueError: If monitoring feature flag is not enabled.
+        """
+        if not self.enable_monitoring:
+            raise ValueError(
+                "Must enable monitoring in Registry to use this method. Please set the `enable_monitoring=True` option"
+            )
+        return self._model_monitor_manager.show_model_monitors()
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
+    def delete_monitor(self, name: str) -> None:
+        """Delete a Model Monitor from the Registry
+
+        Args:
+            name: Name of the Model Monitor to delete.
+
+        Raises:
+            ValueError: If monitoring feature flag is not enabled.
+        """
+        if not self.enable_monitoring:
+            raise ValueError(
+                "Must enable monitoring in Registry to use this method. Please set the `enable_monitoring=True` option"
+            )
+        self._model_monitor_manager.delete_monitor(name)

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.6.1"
+VERSION="1.6.3"

{snowflake_ml_python-1.6.1.dist-info → snowflake_ml_python-1.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-ml-python
-Version: 1.6.1
+Version: 1.6.3
 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: 
@@ -247,13 +247,13 @@ Requires-Dist: pytimeparse <2,>=1.1.8
 Requires-Dist: pyyaml <7,>=6.0
 Requires-Dist: retrying <2,>=1.3.3
 Requires-Dist: s3fs <2024,>=2022.11
-Requires-Dist: scikit-learn <1.4,>=1.2.1
+Requires-Dist: scikit-learn <1.6,>=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.17.0
 Requires-Dist: sqlparse <1,>=0.4
 Requires-Dist: typing-extensions <5,>=4.1.0
-Requires-Dist: xgboost <2,>=1.7.3
+Requires-Dist: xgboost <2.1,>=1.7.3
 Provides-Extra: all
 Requires-Dist: catboost <2,>=1.2.0 ; extra == 'all'
 Requires-Dist: lightgbm <5,>=3.3.5 ; extra == 'all'
@@ -261,7 +261,7 @@ 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 <1,>=0.1.95 ; extra == 'all'
-Requires-Dist: shap ==0.42.1 ; extra == 'all'
+Requires-Dist: shap <1,>=0.42.0 ; extra == 'all'
 Requires-Dist: tensorflow <3,>=2.10 ; extra == 'all'
 Requires-Dist: tokenizers <1,>=0.10 ; extra == 'all'
 Requires-Dist: torch <2.3.0,>=2.0.1 ; extra == 'all'
@@ -276,7 +276,7 @@ Requires-Dist: peft <1,>=0.5.0 ; extra == 'llm'
 Provides-Extra: mlflow
 Requires-Dist: mlflow <2.4,>=2.1.0 ; extra == 'mlflow'
 Provides-Extra: shap
-Requires-Dist: shap ==0.42.1 ; extra == 'shap'
+Requires-Dist: shap <1,>=0.42.0 ; extra == 'shap'
 Provides-Extra: tensorflow
 Requires-Dist: tensorflow <3,>=2.10 ; extra == 'tensorflow'
 Provides-Extra: torch
@@ -373,7 +373,44 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 # Release History
 
-## 1.6.1 (TBD)
+## 1.6.3
+
+- Model Registry (PrPr) has been removed.
+
+### Bug Fixes
+
+- Registry: Fix a bug that when package whose name does not follow PEP-508 is provided when logging the model,
+  an unexpected normalization is happening.
+- Registry: Fix `not a valid remote uri` error when logging mlflow models.
+- Registry: Fix a bug that `ModelVersion.run` is called in a nested way.
+- Registry: Fix an issue that leads to `log_model` failure when local package version contains parts other than
+  base version.
+
+### New Features
+
+- Data: Improve `DataConnector.to_pandas()` performance when loading from Snowpark DataFrames.
+- Model Registry: Allow users to set a model task while using `log_model`.
+- Feature Store: FeatureView supports ON_CREATE or ON_SCHEDULE initialize mode.
+
+## 1.6.2 (2024-09-04)
+
+### Bug Fixes
+
+- Modeling: Support XGBoost version that is larger than 2.
+
+- Data: Fix multiple epoch iteration over `DataConnector.to_torch_datapipe()` DataPipes.
+- Generic: Fix a bug that when an invalid name is provided to argument where fully qualified name is expected, it will
+  be parsed wrongly. Now it raises an exception correctly.
+- Model Explainability: Handle explanations for multiclass XGBoost classification models
+- Model Explainability: Workarounds and better error handling for XGB>2.1.0 not working with SHAP==0.42.1
+
+### New Features
+
+- Data: Add top-level exports for `DataConnector` and `DataSource` to `snowflake.ml.data`.
+- Data: Add native batching support via `batch_size` and `drop_last_batch` arguments to `DataConnector.to_torch_dataset()`
+- Feature Store: update_feature_view() supports taking feature view object as argument.
+
+## 1.6.1 (2024-08-12)
 
 ### Bug Fixes
 
@@ -390,14 +427,11 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 ### New Features
 
 - Enable `set_params` to set the parameters of the underlying sklearn estimator, if the snowflake-ml model has been fit.
-- Data: Add top-level exports for `DataConnector` and `DataSource` to `snowflake.ml.data`.
 - Data: Add `snowflake.ml.data.ingestor_utils` module with utility functions helpful for `DataIngestor` implementations.
 - Data: Add new `to_torch_dataset()` connector to `DataConnector` to replace deprecated DataPipe.
 - Registry: Option to `enable_explainability` set to True by default for XGBoost, LightGBM and CatBoost as PuPr feature.
 - Registry: Option to `enable_explainability` when registering SHAP supported sklearn models.
 
-### Behavior Changes
-
 ## 1.6.0 (2024-07-29)
 
 ### Bug Fixes