snowflake-ml-python 1.13.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

snowflake/ml/model/models/huggingface_pipeline.py

@@ -8,6 +8,7 @@ from snowflake import snowpark
 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._client.model import inference_engine_utils
 from snowflake.ml.model._client.ops import service_ops
 from snowflake.snowpark import async_job, session
 
@@ -77,6 +78,15 @@ class HuggingFacePipelineModel:
         framework = kwargs.get("framework", None)
         feature_extractor = kwargs.get("feature_extractor", None)
 
+        _can_download_snapshot = False
+        if download_snapshot:
+            try:
+                import huggingface_hub as hf_hub
+
+                _can_download_snapshot = True
+            except ImportError:
+                pass
+
         # ==== Start pipeline logic from transformers ====
         if model_kwargs is None:
             model_kwargs = {}
@@ -141,22 +151,23 @@ class HuggingFacePipelineModel:
         # Instantiate config if needed
         config_obj = None
 
-        if isinstance(config, str):
-            config_obj = transformers.AutoConfig.from_pretrained(
-                config, _from_pipeline=task, **hub_kwargs, **model_kwargs
-            )
-            hub_kwargs["_commit_hash"] = config_obj._commit_hash
-        elif config is None and isinstance(model, str):
-            config_obj = transformers.AutoConfig.from_pretrained(
-                model, _from_pipeline=task, **hub_kwargs, **model_kwargs
-            )
-            hub_kwargs["_commit_hash"] = config_obj._commit_hash
-        # We only support string as config argument.
-        elif config is not None and not isinstance(config, str):
-            raise RuntimeError(
-                "Impossible to use non-string config as input for HuggingFacePipelineModel. Use transformers.Pipeline"
-                " object if required."
-            )
+        if not _can_download_snapshot:
+            if isinstance(config, str):
+                config_obj = transformers.AutoConfig.from_pretrained(
+                    config, _from_pipeline=task, **hub_kwargs, **model_kwargs
+                )
+                hub_kwargs["_commit_hash"] = config_obj._commit_hash
+            elif config is None and isinstance(model, str):
+                config_obj = transformers.AutoConfig.from_pretrained(
+                    model, _from_pipeline=task, **hub_kwargs, **model_kwargs
+                )
+                hub_kwargs["_commit_hash"] = config_obj._commit_hash
+            # We only support string as config argument.
+            elif config is not None and not isinstance(config, str):
+                raise RuntimeError(
+                    "Impossible to use non-string config as input for HuggingFacePipelineModel. "
+                    "Use transformers.Pipeline object if required."
+                )
 
         # ==== Start pipeline logic (Task) from transformers ====
 
@@ -208,7 +219,7 @@ class HuggingFacePipelineModel:
                 "Using a pipeline without specifying a model name and revision in production is not recommended.",
                 stacklevel=2,
             )
-            if config is None and isinstance(model, str):
+            if not _can_download_snapshot and config is None and isinstance(model, str):
                 config_obj = transformers.AutoConfig.from_pretrained(
                     model, _from_pipeline=task, **hub_kwargs, **model_kwargs
                 )
@@ -228,11 +239,10 @@ class HuggingFacePipelineModel:
                 )
 
         repo_snapshot_dir: Optional[str] = None
-        if download_snapshot:
+        if _can_download_snapshot:
             try:
-                from huggingface_hub import snapshot_download
 
-                repo_snapshot_dir = snapshot_download(
+                repo_snapshot_dir = hf_hub.snapshot_download(
                     repo_id=model,
                     revision=revision,
                     token=token,
@@ -268,7 +278,7 @@ class HuggingFacePipelineModel:
         ],
     )
     @snowpark._internal.utils.private_preview(version="1.9.1")
-    def create_service(
+    def log_model_and_create_service(
         self,
         *,
         session: session.Session,
@@ -293,6 +303,7 @@ class HuggingFacePipelineModel:
         force_rebuild: bool = False,
         build_external_access_integrations: Optional[list[str]] = None,
         block: bool = True,
+        experimental_options: Optional[dict[str, Any]] = None,
     ) -> Union[str, async_job.AsyncJob]:
         """Logs a Hugging Face model and creates a service in Snowflake.
 
@@ -319,6 +330,10 @@ class HuggingFacePipelineModel:
             force_rebuild: Whether to force rebuild the image. Defaults to False.
             build_external_access_integrations: External access integrations for building the image. Defaults to None.
             block: Whether to block the operation. Defaults to True.
+            experimental_options: Experimental options for the service creation with custom inference engine.
+                Currently, only `inference_engine` and `inference_engine_args_override` are supported.
+                `inference_engine` is the name of the inference engine to use.
+                `inference_engine_args_override` is a list of string arguments to pass to the inference engine.
 
         Raises:
             ValueError: if database and schema name is not provided and session doesn't have a
@@ -360,6 +375,24 @@ class HuggingFacePipelineModel:
         )
         logger.info(f"A service job is going to register the hf model as: {model_name}.{version_name}")
 
+        # Check if model is HuggingFace text-generation before doing inference engine checks
+        inference_engine_args = None
+        if experimental_options:
+            if self.task != "text-generation":
+                raise ValueError(
+                    "Currently, InferenceEngine using experimental_options is only supported for "
+                    "HuggingFace text-generation models."
+                )
+
+            inference_engine_args = inference_engine_utils._get_inference_engine_args(experimental_options)
+
+            # Enrich inference engine args if inference engine is specified
+            if inference_engine_args is not None:
+                inference_engine_args = inference_engine_utils._enrich_inference_engine_args(
+                    inference_engine_args,
+                    gpu_requests,
+                )
+
         from snowflake.ml.model import event_handler
         from snowflake.snowpark import exceptions
 
@@ -412,6 +445,8 @@ class HuggingFacePipelineModel:
                         # TODO: remove warehouse in the next release
                         warehouse=session.get_current_warehouse(),
                     ),
+                    # inference engine
+                    inference_engine_args=inference_engine_args,
                 )
                 status.update(label="HuggingFace model service created successfully", state="complete", expanded=False)
                 return result

snowflake/ml/monitoring/_client/model_monitor_sql_client.py

@@ -30,8 +30,8 @@ class MonitorOperation(Enum):
 _OPERATION_SUPPORTED_PROPS: dict[MonitorOperation, frozenset[str]] = {
     MonitorOperation.SUSPEND: frozenset(),
     MonitorOperation.RESUME: frozenset(),
-    MonitorOperation.ADD: frozenset({"SEGMENT_COLUMN"}),
-    MonitorOperation.DROP: frozenset({"SEGMENT_COLUMN"}),
+    MonitorOperation.ADD: frozenset({"SEGMENT_COLUMN", "CUSTOM_METRIC_COLUMN"}),
+    MonitorOperation.DROP: frozenset({"SEGMENT_COLUMN", "CUSTOM_METRIC_COLUMN"}),
 }
 
 
@@ -91,6 +91,7 @@ class ModelMonitorSQLClient:
         baseline_schema: Optional[sql_identifier.SqlIdentifier] = None,
         baseline: Optional[sql_identifier.SqlIdentifier] = None,
         segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
+        custom_metric_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         baseline_sql = ""
@@ -101,6 +102,10 @@ class ModelMonitorSQLClient:
         if segment_columns:
             segment_columns_sql = f"SEGMENT_COLUMNS={_build_sql_list_from_columns(segment_columns)}"
 
+        custom_metric_columns_sql = ""
+        if custom_metric_columns:
+            custom_metric_columns_sql = f"CUSTOM_METRIC_COLUMNS={_build_sql_list_from_columns(custom_metric_columns)}"
+
         query_result_checker.SqlResultValidator(
             self._sql_client._session,
             f"""
@@ -120,6 +125,7 @@ class ModelMonitorSQLClient:
                     REFRESH_INTERVAL='{refresh_interval}'
                     AGGREGATION_WINDOW='{aggregation_window}'
                     {segment_columns_sql}
+                    {custom_metric_columns_sql}
                     {baseline_sql}""",
             statement_params=statement_params,
         ).has_column("status").has_dimensions(1, 1).validate()
@@ -210,6 +216,7 @@ class ModelMonitorSQLClient:
         actual_class_columns: list[sql_identifier.SqlIdentifier],
         id_columns: list[sql_identifier.SqlIdentifier],
         segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
+        custom_metric_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
     ) -> None:
         """Ensures all columns exist in the source table.
 
@@ -222,12 +229,14 @@ class ModelMonitorSQLClient:
             actual_class_columns: List of actual class column names.
             id_columns: List of id column names.
             segment_columns: List of segment column names.
+            custom_metric_columns: List of custom metric column names.
 
         Raises:
             ValueError: If any of the columns do not exist in the source.
         """
 
         segment_columns = [] if segment_columns is None else segment_columns
+        custom_metric_columns = [] if custom_metric_columns is None else custom_metric_columns
 
         if timestamp_column not in source_column_schema:
             raise ValueError(f"Timestamp column {timestamp_column} does not exist in source.")
@@ -248,6 +257,9 @@ class ModelMonitorSQLClient:
         if not all([column_name in source_column_schema for column_name in segment_columns]):
             raise ValueError(f"Segment column(s): {segment_columns} do not exist in source.")
 
+        if not all([column_name in source_column_schema for column_name in custom_metric_columns]):
+            raise ValueError(f"Custom Metric column(s): {custom_metric_columns} do not exist in source.")
+
     def validate_source(
         self,
         *,
@@ -261,6 +273,7 @@ class ModelMonitorSQLClient:
         actual_class_columns: list[sql_identifier.SqlIdentifier],
         id_columns: list[sql_identifier.SqlIdentifier],
         segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
+        custom_metric_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
     ) -> None:
 
         source_database = source_database or self._database_name
@@ -281,6 +294,7 @@ class ModelMonitorSQLClient:
             actual_class_columns=actual_class_columns,
             id_columns=id_columns,
             segment_columns=segment_columns,
+            custom_metric_columns=custom_metric_columns,
         )
 
     def _alter_monitor(
@@ -299,7 +313,7 @@ class ModelMonitorSQLClient:
 
             if target_property not in supported_target_properties:
                 raise ValueError(
-                    f"Only {', '.join(supported_target_properties)} supported as target property "
+                    f"Only {', '.join(sorted(supported_target_properties))} supported as target property "
                     f"for {operation.name} operation"
                 )
 
@@ -366,3 +380,33 @@ class ModelMonitorSQLClient:
             target_value=segment_column,
             statement_params=statement_params,
         )
+
+    def add_custom_metric_column(
+        self,
+        monitor_name: sql_identifier.SqlIdentifier,
+        custom_metric_column: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Add a custom metric column to the Model Monitor"""
+        self._alter_monitor(
+            operation=MonitorOperation.ADD,
+            monitor_name=monitor_name,
+            target_property="CUSTOM_METRIC_COLUMN",
+            target_value=custom_metric_column,
+            statement_params=statement_params,
+        )
+
+    def drop_custom_metric_column(
+        self,
+        monitor_name: sql_identifier.SqlIdentifier,
+        custom_metric_column: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Drop a custom metric column from the Model Monitor"""
+        self._alter_monitor(
+            operation=MonitorOperation.DROP,
+            monitor_name=monitor_name,
+            target_property="CUSTOM_METRIC_COLUMN",
+            target_value=custom_metric_column,
+            statement_params=statement_params,
+        )

snowflake/ml/monitoring/_manager/model_monitor_manager.py

@@ -109,6 +109,7 @@ class ModelMonitorManager:
         actual_score_columns = self._build_column_list_from_input(source_config.actual_score_columns)
         actual_class_columns = self._build_column_list_from_input(source_config.actual_class_columns)
         segment_columns = self._build_column_list_from_input(source_config.segment_columns)
+        custom_metric_columns = self._build_column_list_from_input(source_config.custom_metric_columns)
 
         id_columns = [sql_identifier.SqlIdentifier(column_name) for column_name in source_config.id_columns]
         ts_column = sql_identifier.SqlIdentifier(source_config.timestamp_column)
@@ -125,6 +126,7 @@ class ModelMonitorManager:
             actual_class_columns=actual_class_columns,
             id_columns=id_columns,
             segment_columns=segment_columns,
+            custom_metric_columns=custom_metric_columns,
         )
 
         self._model_monitor_client.create_model_monitor(
@@ -147,6 +149,7 @@ class ModelMonitorManager:
             actual_score_columns=actual_score_columns,
             actual_class_columns=actual_class_columns,
             segment_columns=segment_columns,
+            custom_metric_columns=custom_metric_columns,
             refresh_interval=model_monitor_config.refresh_interval,
             aggregation_window=model_monitor_config.aggregation_window,
             baseline_database=baseline_database_name_id,

snowflake/ml/monitoring/entities/model_monitor_config.py

@@ -36,6 +36,9 @@ class ModelMonitorSourceConfig:
     segment_columns: Optional[list[str]] = None
     """List of columns in the source containing segment information for grouped monitoring."""
 
+    custom_metric_columns: Optional[list[str]] = None
+    """List of columns in the source containing custom metrics."""
+
 
 @dataclass
 class ModelMonitorConfig:

snowflake/ml/monitoring/model_monitor.py

@@ -72,3 +72,33 @@ class ModelMonitor:
         )
         segment_column_id = sql_identifier.SqlIdentifier(segment_column)
         self._model_monitor_client.drop_segment_column(self.name, segment_column_id, statement_params=statement_params)
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    def add_custom_metric_column(self, custom_metric_column: str) -> None:
+        """Add a custom metric column to the Model Monitor"""
+        statement_params = telemetry.get_statement_params(
+            telemetry.TelemetryProject.MLOPS.value,
+            telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        custom_metric_column_identifier = sql_identifier.SqlIdentifier(custom_metric_column)
+        self._model_monitor_client.add_custom_metric_column(
+            self.name, custom_metric_column_identifier, statement_params=statement_params
+        )
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    def drop_custom_metric_column(self, custom_metric_column: str) -> None:
+        """Drop a custom metric column from the Model Monitor"""
+        statement_params = telemetry.get_statement_params(
+            telemetry.TelemetryProject.MLOPS.value,
+            telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        custom_metric_column_identifier = sql_identifier.SqlIdentifier(custom_metric_column)
+        self._model_monitor_client.drop_custom_metric_column(
+            self.name, custom_metric_column_identifier, statement_params=statement_params
+        )

snowflake/ml/registry/_manager/model_manager.py

@@ -1,8 +1,8 @@
+import logging
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 import pandas as pd
-from absl.logging import logging
 
 from snowflake.ml._internal import platform_capabilities, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions

snowflake/ml/registry/_manager/model_parameter_reconciler.py

@@ -1,8 +1,8 @@
+import logging
 import warnings
 from dataclasses import dataclass
 from typing import Any, Optional
 
-from absl.logging import logging
 from packaging import requirements
 
 from snowflake.ml import version as snowml_version
@@ -221,7 +221,7 @@ class ModelParameterReconciler:
             ).get(env_utils.SNOWPARK_ML_PKG_NAME, [])
 
             if len(snowml_matched_versions) < 1 and not options.get("embed_local_ml_library", False):
-                logging.info(
+                logger.info(
                     f"Local snowflake-ml-python library has version {snowml_version.VERSION},"
                     " which is not available in the Snowflake server, embedding local ML library automatically."
                 )

snowflake/ml/utils/connection_params.py

@@ -1,13 +1,15 @@
 import configparser
+import logging
 import os
 from typing import Optional, Union
 
-from absl import logging
 from cryptography.hazmat import backends
 from cryptography.hazmat.primitives import serialization
 
 from snowflake import snowpark
 
+logger = logging.getLogger(__name__)
+
 _DEFAULT_CONNECTION_FILE = "~/.snowsql/config"
 
 
@@ -108,7 +110,7 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
     """Loads the dictionary from snowsql config file."""
     snowsql_config_file = login_file if login_file else os.path.expanduser(_DEFAULT_CONNECTION_FILE)
     if not os.path.exists(snowsql_config_file):
-        logging.error(f"Connection name given but snowsql config file is not found at: {snowsql_config_file}")
+        logger.error(f"Connection name given but snowsql config file is not found at: {snowsql_config_file}")
         raise Exception("Snowflake SnowSQL config not found.")
 
     config = configparser.ConfigParser(inline_comment_prefixes="#")
@@ -124,7 +126,7 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
         # See https://docs.snowflake.com/en/user-guide/snowsql-start.html#configuring-default-connection-settings
         connection_name = "connections"
 
-    logging.info(f"Reading {snowsql_config_file} for connection parameters defined as {connection_name}")
+    logger.info(f"Reading {snowsql_config_file} for connection parameters defined as {connection_name}")
     config.read(snowsql_config_file)
     conn_params = dict(config[connection_name])
     # Remap names to appropriate args in Python Connector API

snowflake/ml/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "1.13.0"
+VERSION = "1.15.0"

{snowflake_ml_python-1.13.0.dist-info → snowflake_ml_python-1.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.13.0
+Version: 1.15.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: 
@@ -233,7 +233,6 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: absl-py<2,>=0.15
 Requires-Dist: anyio<5,>=3.5.0
 Requires-Dist: cachetools<6,>=3.1.1
 Requires-Dist: cloudpickle>=2.0.0
@@ -302,21 +301,21 @@ Requires-Dist: torch<3,>=2.0.1; extra == "transformers"
 Requires-Dist: transformers!=4.51.3,<5,>=4.39.3; extra == "transformers"
 Dynamic: license-file
 
-# Snowpark ML
+# Snowflake ML Python
 
-Snowpark ML is a set of tools including SDKs and underlying infrastructure to build and deploy machine learning models.
-With Snowpark ML, you can pre-process data, train, manage and deploy ML models all within Snowflake, using a single SDK,
+Snowflake ML Python is a set of tools including SDKs and underlying infrastructure to build and deploy machine learning models.
+With Snowflake ML Python, you can pre-process data, train, manage and deploy ML models all within Snowflake,
 and benefit from Snowflake’s proven performance, scalability, stability and governance at every stage of the Machine
 Learning workflow.
 
-## Key Components of Snowpark ML
+## Key Components of Snowflake ML Python
 
-The Snowpark ML Python SDK provides a number of APIs to support each stage of an end-to-end Machine Learning development
-and deployment process, and includes two key components.
+The Snowflake ML Python SDK provides a number of APIs to support each stage of an end-to-end Machine Learning development
+and deployment process.
 
-### Snowpark ML Development
+### Snowflake ML Model Development
 
-[Snowpark ML Development](https://docs.snowflake.com/en/developer-guide/snowpark-ml/index#ml-modeling)
+[Snowflake ML Model Development](https://docs.snowflake.com/developer-guide/snowflake-ml/overview#ml-modeling)
 provides a collection of python APIs enabling efficient ML model development directly in Snowflake:
 
 1. Modeling API (`snowflake.ml.modeling`) for data preprocessing, feature engineering and model training in Snowflake.
@@ -327,19 +326,16 @@ model development classes based on sklearn, xgboost, and lightgbm.
 1. Framework Connectors: Optimized, secure and performant data provisioning for Pytorch and Tensorflow frameworks in
 their native data loader formats.
 
-1. FileSet API: FileSet provides a Python fsspec-compliant API for materializing data into a Snowflake internal stage
-from a query or Snowpark Dataframe along with a number of convenience APIs.
+### Snowflake ML Ops
 
-### Snowflake MLOps
+Snowflake ML Python contains a suite of MLOps tools. It complements
+the Snowflake Modeling API, and provides end to end development to deployment within Snowflake.
+The Snowflake ML Ops suite consists of:
 
-Snowflake MLOps contains suit of tools and objects to make ML development cycle. It complements
-the Snowpark ML Development API, and provides end to end development to deployment within Snowflake.
-Currently, the API consists of:
-
-1. [Registry](https://docs.snowflake.com/en/developer-guide/snowpark-ml/index#snowflake-model-registry): A python API
+1. [Registry](https://docs.snowflake.com/developer-guide/snowflake-ml/overview#snowflake-model-registry): A python API
   allows secure deployment and management of models in Snowflake, supporting models trained both inside and outside of
   Snowflake.
-2. [Feature Store](https://docs.snowflake.com/en/developer-guide/snowpark-ml/index#snowflake-feature-store): A fully
+2. [Feature Store](https://docs.snowflake.com/developer-guide/snowflake-ml/overview#snowflake-feature-store): A fully
   integrated solution for defining, managing, storing and discovering ML features derived from your data. The
   Snowflake Feature Store supports automated, incremental refresh from batch and streaming data sources, so that
   feature pipelines need be defined only once to be continuously updated with new data.
@@ -348,12 +344,19 @@ Currently, the API consists of:
 
 ## Getting started
 
+Learn about all Snowflake ML feature offerings in the [Developer Guide](https://docs.snowflake.com/developer-guide/snowflake-ml/overview).
+
 ### Have your Snowflake account ready
 
 If you don't have a Snowflake account yet, you can [sign up for a 30-day free trial account](https://signup.snowflake.com/).
 
 ### Installation
 
+Snowflake ML Python is pre-installed in Container Runtime notebook environments.
+[Learn more](https://docs.snowflake.com/en/developer-guide/snowflake-ml/notebooks-on-spcs).
+
+In Snowflake Warehouse notebook environments, snowflake-ml-python can be installed using the "Packages" drop-down menu.
+
 Follow the [installation instructions](https://docs.snowflake.com/en/developer-guide/snowpark-ml/index#installing-snowpark-ml)
 in the Snowflake documentation.
 
@@ -363,8 +366,8 @@ or [virtualenv](https://docs.python.org/3/tutorial/venv.html) to create a virtua
 
 ### Conda channels
 
-The [Snowflake Conda Channel](https://repo.anaconda.com/pkgs/snowflake/) contains the official snowpark ML package releases.
-The recommended approach is to install `snowflake-ml-python` this conda channel:
+The [Snowflake Anaconda Channel](https://repo.anaconda.com/pkgs/snowflake/) contains the official snowflake-ml-python package
+releases. To install `snowflake-ml-python` from this conda channel:
 
 ```sh
 conda install \
@@ -373,25 +376,18 @@ conda install \
   snowflake-ml-python
 ```
 
-See [the developer guide](https://docs.snowflake.com/en/developer-guide/snowpark-ml/index) for installation instructions.
+See [the developer guide](https://docs.snowflake.com/en/developer-guide/snowpark-ml/index) for detailed installation instructions.
 
-The latest version of the `snowpark-ml-python` package is also published in a conda channel in this repository. Package versions
-in this channel may not yet be present in the official Snowflake conda channel.
+The snowflake-ml-python package is also published in [conda-forge](https://anaconda.org/conda-forge/snowflake-ml-python).
+To install `snowflake-ml-python` from conda forge:
 
-Install `snowflake-ml-python` from this channel with the following (being sure to replace `<version_specifier>` with the
-desired version, e.g. `1.0.10`):
-
-```bash
+```sh
 conda install \
-  -c https://raw.githubusercontent.com/snowflakedb/snowflake-ml-python/conda/releases/  \
-  -c https://repo.anaconda.com/pkgs/snowflake \
+  -c https://conda.anaconda.org/conda-forge/ \
   --override-channels \
-  snowflake-ml-python==<version_specifier>
+  snowflake-ml-python
 ```
 
-Note that until a `snowflake-ml-python` package version is available in the official Snowflake conda channel, there may
-be compatibility issues. Server-side functionality that `snowflake-ml-python` depends on may not yet be released.
-
 ### Verifying the package
 
 1. Install cosign.
@@ -410,6 +406,27 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.15.0
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: Dropping support for deprecated `conversational` task type for Huggingface models.
+  To read more <https://github.com/huggingface/transformers/pull/31165>
+
+### New Features
+
+## 1.14.0 (09-18-2025)
+
+### Bug Fixes
+
+### Behavior Changes
+
+### New Features
+
+* ML Job: The `additional_payloads` argument is now **deprecated** in favor of `imports`.
+
 ## 1.13.0
 
 ### Bug Fixes