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

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

@@ -45,7 +45,7 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
     _MIN_SNOWPARK_ML_VERSION = "1.0.12"
     _HANDLER_MIGRATOR_PLANS: Dict[str, Type[base_migrator.BaseModelHandlerMigrator]] = {}
 
-    MODELE_BLOB_FILE_OR_DIR = "model.ubj"
+    MODEL_BLOB_FILE_OR_DIR = "model.ubj"
     DEFAULT_TARGET_METHODS = ["predict", "predict_proba"]
     _BINARY_CLASSIFICATION_OBJECTIVE_PREFIX = ["binary:"]
     _MULTI_CLASSIFICATION_OBJECTIVE_PREFIX = ["multi:"]
@@ -53,33 +53,35 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
     _REGRESSION_OBJECTIVE_PREFIX = ["reg:"]
 
     @classmethod
-    def get_model_objective(cls, model: Union["xgboost.Booster", "xgboost.XGBModel"]) -> _base.ModelObjective:
+    def get_model_objective(
+        cls, model: Union["xgboost.Booster", "xgboost.XGBModel"]
+    ) -> model_meta_schema.ModelObjective:
         import xgboost
 
         if isinstance(model, xgboost.XGBClassifier) or isinstance(model, xgboost.XGBRFClassifier):
             num_classes = handlers_utils.get_num_classes_if_exists(model)
             if num_classes == 2:
-                return _base.ModelObjective.BINARY_CLASSIFICATION
-            return _base.ModelObjective.MULTI_CLASSIFICATION
+                return model_meta_schema.ModelObjective.BINARY_CLASSIFICATION
+            return model_meta_schema.ModelObjective.MULTI_CLASSIFICATION
         if isinstance(model, xgboost.XGBRegressor) or isinstance(model, xgboost.XGBRFRegressor):
-            return _base.ModelObjective.REGRESSION
+            return model_meta_schema.ModelObjective.REGRESSION
         if isinstance(model, xgboost.XGBRanker):
-            return _base.ModelObjective.RANKING
+            return model_meta_schema.ModelObjective.RANKING
         model_params = json.loads(model.save_config())
         model_objective = model_params["learner"]["objective"]
         for classification_objective in cls._BINARY_CLASSIFICATION_OBJECTIVE_PREFIX:
             if classification_objective in model_objective:
-                return _base.ModelObjective.BINARY_CLASSIFICATION
+                return model_meta_schema.ModelObjective.BINARY_CLASSIFICATION
         for classification_objective in cls._MULTI_CLASSIFICATION_OBJECTIVE_PREFIX:
             if classification_objective in model_objective:
-                return _base.ModelObjective.MULTI_CLASSIFICATION
+                return model_meta_schema.ModelObjective.MULTI_CLASSIFICATION
         for ranking_objective in cls._RANKING_OBJECTIVE_PREFIX:
             if ranking_objective in model_objective:
-                return _base.ModelObjective.RANKING
+                return model_meta_schema.ModelObjective.RANKING
         for regression_objective in cls._REGRESSION_OBJECTIVE_PREFIX:
             if regression_objective in model_objective:
-                return _base.ModelObjective.REGRESSION
-        return _base.ModelObjective.UNKNOWN
+                return model_meta_schema.ModelObjective.REGRESSION
+        return model_meta_schema.ModelObjective.UNKNOWN
 
     @classmethod
     def can_handle(
@@ -146,9 +148,11 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
                 sample_input_data=sample_input_data,
                 get_prediction_fn=get_prediction,
             )
-            if kwargs.get("enable_explainability", False):
+            model_objective = cls.get_model_objective(model)
+            model_meta.model_objective = model_objective
+            if kwargs.get("enable_explainability", True):
                 output_type = model_signature.DataType.DOUBLE
-                if cls.get_model_objective(model) == _base.ModelObjective.MULTI_CLASSIFICATION:
+                if model_objective == model_meta_schema.ModelObjective.MULTI_CLASSIFICATION:
                     output_type = model_signature.DataType.STRING
                 model_meta = handlers_utils.add_explain_method_signature(
                     model_meta=model_meta,
@@ -156,15 +160,18 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
                     target_method="predict",
                     output_return_type=output_type,
                 )
+                model_meta.function_properties = {
+                    "explain": {model_meta_schema.FunctionProperties.PARTITIONED.value: False}
+                }
 
         model_blob_path = os.path.join(model_blobs_dir_path, name)
         os.makedirs(model_blob_path, exist_ok=True)
-        model.save_model(os.path.join(model_blob_path, cls.MODELE_BLOB_FILE_OR_DIR))
+        model.save_model(os.path.join(model_blob_path, cls.MODEL_BLOB_FILE_OR_DIR))
         base_meta = model_blob_meta.ModelBlobMeta(
             name=name,
             model_type=cls.HANDLER_TYPE,
             handler_version=cls.HANDLER_VERSION,
-            path=cls.MODELE_BLOB_FILE_OR_DIR,
+            path=cls.MODEL_BLOB_FILE_OR_DIR,
             options=model_meta_schema.XgboostModelBlobOptions({"xgb_estimator_type": model.__class__.__name__}),
         )
         model_meta.models[name] = base_meta
@@ -177,11 +184,12 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
             ],
             check_local_version=True,
         )
-        if kwargs.get("enable_explainability", False):
+        if kwargs.get("enable_explainability", True):
             model_meta.env.include_if_absent(
                 [model_env.ModelDependency(requirement="shap", pip_name="shap")],
                 check_local_version=True,
             )
+            model_meta.explain_algorithm = model_meta_schema.ModelExplainAlgorithm.SHAP
         model_meta.env.cuda_version = kwargs.get("cuda_version", model_env.DEFAULT_CUDA_VERSION)
 
     @classmethod
@@ -224,6 +232,7 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
         cls,
         raw_model: Union["xgboost.Booster", "xgboost.XGBModel"],
         model_meta: model_meta_api.ModelMetadata,
+        background_data: Optional[pd.DataFrame] = None,
         **kwargs: Unpack[model_types.XGBModelLoadOptions],
     ) -> custom_model.CustomModel:
         import xgboost

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -237,6 +237,7 @@ class ModelMetadata:
         function_properties: A dict mapping function names to dict mapping function property key to value.
         metadata: User provided key-value metadata of the model. Defaults to None.
         creation_timestamp: Unix timestamp when the model metadata is created.
+        model_objective: Model objective like regression, classification etc.
     """
 
     def telemetry_metadata(self) -> ModelMetadataTelemetryDict:
@@ -260,6 +261,8 @@ class ModelMetadata:
         min_snowpark_ml_version: Optional[str] = None,
         models: Optional[Dict[str, model_blob_meta.ModelBlobMeta]] = None,
         original_metadata_version: Optional[str] = model_meta_schema.MODEL_METADATA_VERSION,
+        model_objective: Optional[model_meta_schema.ModelObjective] = model_meta_schema.ModelObjective.UNKNOWN,
+        explain_algorithm: Optional[model_meta_schema.ModelExplainAlgorithm] = None,
     ) -> None:
         self.name = name
         self.signatures: Dict[str, model_signature.ModelSignature] = dict()
@@ -284,6 +287,11 @@ class ModelMetadata:
 
         self.original_metadata_version = original_metadata_version
 
+        self.model_objective: model_meta_schema.ModelObjective = (
+            model_objective or model_meta_schema.ModelObjective.UNKNOWN
+        )
+        self.explain_algorithm: Optional[model_meta_schema.ModelExplainAlgorithm] = explain_algorithm
+
     @property
     def min_snowpark_ml_version(self) -> str:
         return self._min_snowpark_ml_version.base_version
@@ -321,9 +329,11 @@ class ModelMetadata:
         model_dict = model_meta_schema.ModelMetadataDict(
             {
                 "creation_timestamp": self.creation_timestamp,
-                "env": self.env.save_as_dict(pathlib.Path(model_dir_path)),
+                "env": self.env.save_as_dict(
+                    pathlib.Path(model_dir_path), default_channel_override=env_utils.SNOWFLAKE_CONDA_CHANNEL_URL
+                ),
                 "runtimes": {
-                    runtime_name: runtime.save(pathlib.Path(model_dir_path))
+                    runtime_name: runtime.save(pathlib.Path(model_dir_path), default_channel_override="conda-forge")
                     for runtime_name, runtime in self.runtimes.items()
                 },
                 "metadata": self.metadata,
@@ -333,6 +343,13 @@ class ModelMetadata:
                 "signatures": {func_name: sig.to_dict() for func_name, sig in self.signatures.items()},
                 "version": model_meta_schema.MODEL_METADATA_VERSION,
                 "min_snowpark_ml_version": self.min_snowpark_ml_version,
+                "model_objective": self.model_objective.value,
+                "explainability": (
+                    model_meta_schema.ExplainabilityMetadataDict(algorithm=self.explain_algorithm.value)
+                    if self.explain_algorithm
+                    else None
+                ),
+                "function_properties": self.function_properties,
             }
         )
 
@@ -370,6 +387,9 @@ class ModelMetadata:
             signatures=loaded_meta["signatures"],
             version=original_loaded_meta_version,
             min_snowpark_ml_version=loaded_meta_min_snowpark_ml_version,
+            model_objective=loaded_meta.get("model_objective", model_meta_schema.ModelObjective.UNKNOWN.value),
+            explainability=loaded_meta.get("explainability", None),
+            function_properties=loaded_meta.get("function_properties", {}),
         )
 
     @classmethod
@@ -406,6 +426,11 @@ class ModelMetadata:
         else:
             runtimes = None
 
+        explanation_algorithm_dict = model_dict.get("explainability", None)
+        explanation_algorithm = None
+        if explanation_algorithm_dict:
+            explanation_algorithm = model_meta_schema.ModelExplainAlgorithm(explanation_algorithm_dict["algorithm"])
+
         return cls(
             name=model_dict["name"],
             model_type=model_dict["model_type"],
@@ -417,4 +442,9 @@ class ModelMetadata:
             min_snowpark_ml_version=model_dict["min_snowpark_ml_version"],
             models=models,
             original_metadata_version=model_dict["version"],
+            model_objective=model_meta_schema.ModelObjective(
+                model_dict.get("model_objective", model_meta_schema.ModelObjective.UNKNOWN.value)
+            ),
+            explain_algorithm=explanation_algorithm,
+            function_properties=model_dict.get("function_properties", {}),
         )

snowflake/ml/model/_packager/model_meta/model_meta_schema.py

@@ -71,6 +71,10 @@ ModelBlobOptions = Union[
 ]
 
 
+class ExplainabilityMetadataDict(TypedDict):
+    algorithm: Required[str]
+
+
 class ModelBlobMetadataDict(TypedDict):
     name: Required[str]
     model_type: Required[type_hints.SupportedModelHandlerType]
@@ -92,3 +96,18 @@ class ModelMetadataDict(TypedDict):
     signatures: Required[Dict[str, Dict[str, Any]]]
     version: Required[str]
     min_snowpark_ml_version: Required[str]
+    model_objective: Required[str]
+    explainability: NotRequired[Optional[ExplainabilityMetadataDict]]
+    function_properties: NotRequired[Dict[str, Dict[str, Any]]]
+
+
+class ModelObjective(Enum):
+    UNKNOWN = "unknown"
+    BINARY_CLASSIFICATION = "binary_classification"
+    MULTI_CLASSIFICATION = "multi_classification"
+    REGRESSION = "regression"
+    RANKING = "ranking"
+
+
+class ModelExplainAlgorithm(Enum):
+    SHAP = "shap"

snowflake/ml/model/_packager/model_packager.py

@@ -146,7 +146,8 @@ class ModelPackager:
         m = handler.load_model(self.meta.name, self.meta, model_blobs_path, **options)
 
         if as_custom_model:
-            m = handler.convert_as_custom_model(m, self.meta, **options)
+            background_data = handler.load_background_data(self.meta.name, model_blobs_path)
+            m = handler.convert_as_custom_model(m, self.meta, background_data, **options)
             assert isinstance(m, custom_model.CustomModel)
 
         self.model = m

snowflake/ml/model/_packager/model_runtime/model_runtime.py

@@ -67,7 +67,9 @@ class ModelRuntime:
     def runtime_rel_path(self) -> pathlib.PurePosixPath:
         return pathlib.PurePosixPath(ModelRuntime.RUNTIME_DIR_REL_PATH) / self.name
 
-    def save(self, packager_path: pathlib.Path) -> model_meta_schema.ModelRuntimeDict:
+    def save(
+        self, packager_path: pathlib.Path, default_channel_override: str = env_utils.SNOWFLAKE_CONDA_CHANNEL_URL
+    ) -> model_meta_schema.ModelRuntimeDict:
         runtime_base_path = packager_path / self.runtime_rel_path
         runtime_base_path.mkdir(parents=True, exist_ok=True)
 
@@ -80,7 +82,7 @@ class ModelRuntime:
         self.runtime_env.conda_env_rel_path = self.runtime_rel_path / self.runtime_env.conda_env_rel_path
         self.runtime_env.pip_requirements_rel_path = self.runtime_rel_path / self.runtime_env.pip_requirements_rel_path
 
-        env_dict = self.runtime_env.save_as_dict(packager_path)
+        env_dict = self.runtime_env.save_as_dict(packager_path, default_channel_override=default_channel_override)
 
         return model_meta_schema.ModelRuntimeDict(
             imports=list(map(str, self.imports)),

snowflake/ml/model/type_hints.py

@@ -233,12 +233,12 @@ class BaseModelSaveOption(TypedDict):
     function_type: NotRequired[Literal["FUNCTION", "TABLE_FUNCTION"]]
     method_options: NotRequired[Dict[str, ModelMethodSaveOptions]]
     include_pip_dependencies: NotRequired[bool]
+    enable_explainability: NotRequired[bool]
 
 
 class CatBoostModelSaveOptions(BaseModelSaveOption):
     target_methods: NotRequired[Sequence[str]]
     cuda_version: NotRequired[str]
-    enable_explainability: NotRequired[bool]
 
 
 class CustomModelSaveOption(BaseModelSaveOption):
@@ -252,12 +252,10 @@ class SKLModelSaveOptions(BaseModelSaveOption):
 class XGBModelSaveOptions(BaseModelSaveOption):
     target_methods: NotRequired[Sequence[str]]
     cuda_version: NotRequired[str]
-    enable_explainability: NotRequired[bool]
 
 
 class LGBMModelSaveOptions(BaseModelSaveOption):
     target_methods: NotRequired[Sequence[str]]
-    enable_explainability: NotRequired[bool]
 
 
 class SNOWModelSaveOptions(BaseModelSaveOption):

snowflake/ml/modeling/framework/base.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 import inspect
 from abc import abstractmethod
-from collections import defaultdict
 from datetime import datetime
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Union, overload
 
@@ -18,6 +17,7 @@ from snowflake.ml._internal.exceptions import (
 )
 from snowflake.ml._internal.lineage import lineage_utils
 from snowflake.ml._internal.utils import identifier, parallelize
+from snowflake.ml.data import data_source
 from snowflake.ml.modeling.framework import _utils
 from snowflake.snowpark import functions as F
 
@@ -246,7 +246,7 @@ class Base:
 
     def get_params(self, deep: bool = True) -> Dict[str, Any]:
         """
-        Get parameters for this transformer.
+        Get the snowflake-ml parameters for this transformer.
 
         Args:
             deep: If True, will return the parameters for this transformer and
@@ -265,13 +265,13 @@ class Base:
                 out[key] = value
         return out
 
-    def set_params(self, **params: Dict[str, Any]) -> None:
+    def set_params(self, **params: Any) -> None:
         """
         Set the parameters of this transformer.
 
-        The method works on simple transformers as well as on nested objects.
-        The latter have parameters of the form ``<component>__<parameter>``
-        so that it's possible to update each component of a nested object.
+        The method works on simple transformers as well as on sklearn compatible pipelines with nested
+        objects, once the transformer has been fit. Nested objects have parameters of the form
+        ``<component>__<parameter>`` so that it's possible to update each component of a nested object.
 
         Args:
             **params: Transformer parameter names mapped to their values.
@@ -283,12 +283,28 @@ class Base:
             # simple optimization to gain speed (inspect is slow)
             return
         valid_params = self.get_params(deep=True)
+        valid_skl_params = {}
+        if hasattr(self, "_sklearn_object") and self._sklearn_object is not None:
+            valid_skl_params = self._sklearn_object.get_params()
 
-        nested_params: Dict[str, Any] = defaultdict(dict)  # grouped by prefix
         for key, value in params.items():
-            key, delim, sub_key = key.partition("__")
-            if key not in valid_params:
-                local_valid_params = self._get_param_names()
+            if valid_params.get("steps"):
+                # Recurse through pipeline steps
+                key, _, sub_key = key.partition("__")
+                for name, nested_object in valid_params["steps"]:
+                    if name == key:
+                        nested_object.set_params(**{sub_key: value})
+
+            elif key in valid_params:
+                setattr(self, key, value)
+                valid_params[key] = value
+            elif key in valid_skl_params:
+                # This dictionary would be empty if the following assert were not true, as specified above.
+                assert hasattr(self, "_sklearn_object") and self._sklearn_object is not None
+                setattr(self._sklearn_object, key, value)
+                valid_skl_params[key] = value
+            else:
+                local_valid_params = self._get_param_names() + list(valid_skl_params.keys())
                 raise exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_ARGUMENT,
                     original_exception=ValueError(
@@ -298,15 +314,6 @@ class Base:
                     ),
                 )
 
-            if delim:
-                nested_params[key][sub_key] = value
-            else:
-                setattr(self, key, value)
-                valid_params[key] = value
-
-        for key, sub_params in nested_params.items():
-            valid_params[key].set_params(**sub_params)
-
     def get_sklearn_args(
         self,
         default_sklearn_obj: Optional[object] = None,
@@ -427,6 +434,8 @@ class BaseEstimator(Base):
     def fit(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> "BaseEstimator":
         """Runs universal logics for all fit implementations."""
         data_sources = lineage_utils.get_data_sources(dataset)
+        if not data_sources and isinstance(dataset, snowpark.DataFrame):
+            data_sources = [data_source.DataFrameInfo(dataset.queries["queries"][-1])]
         lineage_utils.set_data_sources(self, data_sources)
         return self._fit(dataset)
 

snowflake/ml/modeling/pipeline/pipeline.py

@@ -19,6 +19,7 @@ from snowflake.ml._internal import file_utils, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.lineage import lineage_utils
 from snowflake.ml._internal.utils import snowpark_dataframe_utils, temp_file_utils
+from snowflake.ml.data import data_source
 from snowflake.ml.model.model_signature import ModelSignature, _infer_signature
 from snowflake.ml.modeling._internal.model_transformer_builder import (
     ModelTransformerBuilder,
@@ -431,6 +432,8 @@ class Pipeline(base.BaseTransformer):
 
         # Extract lineage information here since we're overriding fit() directly
         data_sources = lineage_utils.get_data_sources(dataset)
+        if not data_sources and isinstance(dataset, snowpark.DataFrame):
+            data_sources = [data_source.DataFrameInfo(dataset.queries["queries"][-1])]
         lineage_utils.set_data_sources(self, data_sources)
 
         if self._can_be_trained_in_ml_runtime(dataset):

snowflake/ml/registry/_manager/model_manager.py

@@ -9,7 +9,7 @@ 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._client.ops import metadata_ops, model_ops, service_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
@@ -30,6 +30,9 @@ class ModelManager:
         self._model_ops = model_ops.ModelOperator(
             session, database_name=self._database_name, schema_name=self._schema_name
         )
+        self._service_ops = service_ops.ServiceOperator(
+            session, database_name=self._database_name, schema_name=self._schema_name
+        )
         self._hrid_generator = hrid_generator.HRID16()
 
     def log_model(
@@ -173,11 +176,16 @@ class ModelManager:
         )
 
         mv = model_version_impl.ModelVersion._ref(
-            model_ops.ModelOperator(
+            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,
             ),
+            service_ops=service_ops.ServiceOperator(
+                self._service_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,
         )
@@ -216,6 +224,11 @@ class ModelManager:
                     database_name=database_name_id or self._database_name,
                     schema_name=schema_name_id or self._schema_name,
                 ),
+                service_ops=service_ops.ServiceOperator(
+                    self._service_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:
@@ -234,6 +247,7 @@ class ModelManager:
         return [
             model_impl.Model._ref(
                 self._model_ops,
+                service_ops=self._service_ops,
                 model_name=model_name,
             )
             for model_name in model_names

snowflake/ml/utils/sql_client.py

@@ -0,0 +1,22 @@
+from enum import Enum
+from typing import Dict
+
+
+class CreationOption(Enum):
+    FAIL_IF_NOT_EXIST = 1
+    CREATE_IF_NOT_EXIST = 2
+    OR_REPLACE = 3
+
+
+class CreationMode:
+    def __init__(self, *, if_not_exists: bool = False, or_replace: bool = False) -> None:
+        self.if_not_exists = if_not_exists
+        self.or_replace = or_replace
+
+    def get_ddl_phrases(self) -> Dict[CreationOption, str]:
+        if_not_exists_sql = " IF NOT EXISTS" if self.if_not_exists else ""
+        or_replace_sql = " OR REPLACE" if self.or_replace else ""
+        return {
+            CreationOption.CREATE_IF_NOT_EXIST: if_not_exists_sql,
+            CreationOption.OR_REPLACE: or_replace_sql,
+        }

snowflake/ml/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-ml-python
-Version: 1.6.0
+Version: 1.6.1
 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: 
@@ -373,7 +373,32 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 # Release History
 
-## 1.6.0
+## 1.6.1 (TBD)
+
+### Bug Fixes
+
+- Feature Store: Support large metadata blob when generating dataset
+- Feature Store: Added a hidden knob in FeatureView as kargs for setting customized
+  refresh_mode
+- Registry: Fix an error message in Model Version `run` when `function_name` is not mentioned and model has multiple
+  target methods.
+- Cortex inference: snowflake.cortex.Complete now only uses the REST API for streaming and the use_rest_api_experimental
+  is no longer needed.
+- Feature Store: Add a new API: FeatureView.list_columns() which list all column information.
+- Data: Fix `DataFrame` ingestion with `ArrowIngestor`.
+
+### 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
 
@@ -402,6 +427,14 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
   distributed_hpo_trainer.ENABLE_EFFICIENT_MEMORY_USAGE = False
   `
 - Registry: Option to `enable_explainability` when registering LightGBM models as a pre-PuPr feature.
+- Data: Add new `snowflake.ml.data` preview module which contains data reading utilities like `DataConnector`
+  - `DataConnector` provides efficient connectors from Snowpark `DataFrame`
+  and Snowpark ML `Dataset` to external frameworks like PyTorch, TensorFlow, and Pandas. Create `DataConnector`
+  instances using the classmethod constructors `DataConnector.from_dataset()` and `DataConnector.from_dataframe()`.
+- Data: Add new `DataConnector.from_sources()` classmethod constructor for constructing from `DataSource` objects.
+- Data: Add new `ingestor_class` arg to `DataConnector` classmethod constructors for easier `DataIngestor` injection.
+- Dataset: `DatasetReader` now subclasses new `DataConnector` class.
+  - Add optional `limit` arg to `DatasetReader.to_pandas()`
 
 ### Behavior Changes