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

snowflake/ml/monitoring/_client/model_monitor_sql_client.py

@@ -1,3 +1,4 @@
+from enum import Enum, auto
 from typing import Any, Mapping, Optional
 
 from snowflake import snowpark
@@ -15,6 +16,25 @@ MODEL_JSON_MODEL_NAME_FIELD = "model_name"
 MODEL_JSON_VERSION_NAME_FIELD = "version_name"
 
 
+class MonitorOperation(Enum):
+    SUSPEND = auto()
+    RESUME = auto()
+    ADD = auto()
+    DROP = auto()
+
+    @property
+    def supported_target_properties(self) -> frozenset[str]:
+        return _OPERATION_SUPPORTED_PROPS[self]
+
+
+_OPERATION_SUPPORTED_PROPS: dict[MonitorOperation, frozenset[str]] = {
+    MonitorOperation.SUSPEND: frozenset(),
+    MonitorOperation.RESUME: frozenset(),
+    MonitorOperation.ADD: frozenset({"SEGMENT_COLUMN"}),
+    MonitorOperation.DROP: frozenset({"SEGMENT_COLUMN"}),
+}
+
+
 def _build_sql_list_from_columns(columns: list[sql_identifier.SqlIdentifier]) -> str:
     sql_list = ", ".join([f"'{column}'" for column in columns])
     return f"({sql_list})"
@@ -70,11 +90,17 @@ class ModelMonitorSQLClient:
         baseline_database: Optional[sql_identifier.SqlIdentifier] = None,
         baseline_schema: Optional[sql_identifier.SqlIdentifier] = None,
         baseline: Optional[sql_identifier.SqlIdentifier] = None,
+        segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         baseline_sql = ""
         if baseline:
             baseline_sql = f"""BASELINE={self._infer_qualified_schema(baseline_database, baseline_schema)}.{baseline}"""
+
+        segment_columns_sql = ""
+        if segment_columns:
+            segment_columns_sql = f"SEGMENT_COLUMNS={_build_sql_list_from_columns(segment_columns)}"
+
         query_result_checker.SqlResultValidator(
             self._sql_client._session,
             f"""
@@ -93,6 +119,7 @@ class ModelMonitorSQLClient:
                     TIMESTAMP_COLUMN='{timestamp_column}'
                     REFRESH_INTERVAL='{refresh_interval}'
                     AGGREGATION_WINDOW='{aggregation_window}'
+                    {segment_columns_sql}
                     {baseline_sql}""",
             statement_params=statement_params,
         ).has_column("status").has_dimensions(1, 1).validate()
@@ -182,6 +209,7 @@ class ModelMonitorSQLClient:
         actual_score_columns: list[sql_identifier.SqlIdentifier],
         actual_class_columns: list[sql_identifier.SqlIdentifier],
         id_columns: list[sql_identifier.SqlIdentifier],
+        segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
     ) -> None:
         """Ensures all columns exist in the source table.
 
@@ -193,11 +221,14 @@ class ModelMonitorSQLClient:
             actual_score_columns: List of actual score column names.
             actual_class_columns: List of actual class column names.
             id_columns: List of id column names.
+            segment_columns: List of segment 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
+
         if timestamp_column not in source_column_schema:
             raise ValueError(f"Timestamp column {timestamp_column} does not exist in source.")
 
@@ -214,6 +245,9 @@ class ModelMonitorSQLClient:
         if not all([column_name in source_column_schema for column_name in id_columns]):
             raise ValueError(f"ID column(s): {id_columns} do not exist in source.")
 
+        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.")
+
     def validate_source(
         self,
         *,
@@ -226,7 +260,9 @@ class ModelMonitorSQLClient:
         actual_score_columns: list[sql_identifier.SqlIdentifier],
         actual_class_columns: list[sql_identifier.SqlIdentifier],
         id_columns: list[sql_identifier.SqlIdentifier],
+        segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
     ) -> None:
+
         source_database = source_database or self._database_name
         source_schema = source_schema or self._schema_name
         # Get Schema of the source. Implicitly validates that the source exists.
@@ -244,19 +280,38 @@ class ModelMonitorSQLClient:
             actual_score_columns=actual_score_columns,
             actual_class_columns=actual_class_columns,
             id_columns=id_columns,
+            segment_columns=segment_columns,
         )
 
     def _alter_monitor(
         self,
-        operation: str,
+        operation: MonitorOperation,
         monitor_name: sql_identifier.SqlIdentifier,
+        target_property: Optional[str] = None,
+        target_value: Optional[sql_identifier.SqlIdentifier] = None,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
-        if operation not in {"SUSPEND", "RESUME"}:
-            raise ValueError(f"Operation {operation} not supported for altering Dynamic Tables")
+        supported_target_properties = operation.supported_target_properties
+
+        if supported_target_properties:
+            if target_property is None or target_value is None:
+                raise ValueError(f"Target property and value must be provided for {operation.name} operation")
+
+            if target_property not in supported_target_properties:
+                raise ValueError(
+                    f"Only {', '.join(supported_target_properties)} supported as target property "
+                    f"for {operation.name} operation"
+                )
+
+        property_clause = f"{target_property}={target_value}" if target_property and target_value else ""
+        alter_momo_sql = (
+            f"""ALTER MODEL MONITOR {self._database_name}.{self._schema_name}.{monitor_name} """
+            f"""{operation.name} {property_clause}"""
+        )
+
         query_result_checker.SqlResultValidator(
             self._sql_client._session,
-            f"""ALTER MODEL MONITOR {self._database_name}.{self._schema_name}.{monitor_name} {operation}""",
+            alter_momo_sql,
             statement_params=statement_params,
         ).has_column("status").has_dimensions(1, 1).validate()
 
@@ -266,7 +321,7 @@ class ModelMonitorSQLClient:
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._alter_monitor(
-            operation="SUSPEND",
+            operation=MonitorOperation.SUSPEND,
             monitor_name=monitor_name,
             statement_params=statement_params,
         )
@@ -277,7 +332,37 @@ class ModelMonitorSQLClient:
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         self._alter_monitor(
-            operation="RESUME",
+            operation=MonitorOperation.RESUME,
+            monitor_name=monitor_name,
+            statement_params=statement_params,
+        )
+
+    def add_segment_column(
+        self,
+        monitor_name: sql_identifier.SqlIdentifier,
+        segment_column: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Add a segment column to the Model Monitor"""
+        self._alter_monitor(
+            operation=MonitorOperation.ADD,
+            monitor_name=monitor_name,
+            target_property="SEGMENT_COLUMN",
+            target_value=segment_column,
+            statement_params=statement_params,
+        )
+
+    def drop_segment_column(
+        self,
+        monitor_name: sql_identifier.SqlIdentifier,
+        segment_column: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Drop a segment column from the Model Monitor"""
+        self._alter_monitor(
+            operation=MonitorOperation.DROP,
             monitor_name=monitor_name,
+            target_property="SEGMENT_COLUMN",
+            target_value=segment_column,
             statement_params=statement_params,
         )

snowflake/ml/monitoring/_manager/model_monitor_manager.py

@@ -108,6 +108,7 @@ class ModelMonitorManager:
         prediction_class_columns = self._build_column_list_from_input(source_config.prediction_class_columns)
         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)
 
         id_columns = [sql_identifier.SqlIdentifier(column_name) for column_name in source_config.id_columns]
         ts_column = sql_identifier.SqlIdentifier(source_config.timestamp_column)
@@ -123,6 +124,7 @@ class ModelMonitorManager:
             actual_score_columns=actual_score_columns,
             actual_class_columns=actual_class_columns,
             id_columns=id_columns,
+            segment_columns=segment_columns,
         )
 
         self._model_monitor_client.create_model_monitor(
@@ -144,6 +146,7 @@ class ModelMonitorManager:
             prediction_class_columns=prediction_class_columns,
             actual_score_columns=actual_score_columns,
             actual_class_columns=actual_class_columns,
+            segment_columns=segment_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

@@ -33,6 +33,9 @@ class ModelMonitorSourceConfig:
     baseline: Optional[str] = None
     """Name of table containing the baseline data."""
 
+    segment_columns: Optional[list[str]] = None
+    """List of columns in the source containing segment information for grouped monitoring."""
+
 
 @dataclass
 class ModelMonitorConfig:

snowflake/ml/monitoring/model_monitor.py

@@ -46,3 +46,29 @@ class ModelMonitor:
             telemetry.TelemetrySubProject.MONITORING.value,
         )
         self._model_monitor_client.resume_monitor(self.name, statement_params=statement_params)
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    def add_segment_column(self, segment_column: str) -> None:
+        """Add a segment column to the Model Monitor"""
+        statement_params = telemetry.get_statement_params(
+            telemetry.TelemetryProject.MLOPS.value,
+            telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        segment_column_id = sql_identifier.SqlIdentifier(segment_column)
+        self._model_monitor_client.add_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 drop_segment_column(self, segment_column: str) -> None:
+        """Drop a segment column from the Model Monitor"""
+        statement_params = telemetry.get_statement_params(
+            telemetry.TelemetryProject.MLOPS.value,
+            telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        segment_column_id = sql_identifier.SqlIdentifier(segment_column)
+        self._model_monitor_client.drop_segment_column(self.name, segment_column_id, statement_params=statement_params)

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.11.0"
+VERSION = "1.13.0"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.11.0
+Version: 1.13.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: 
@@ -244,17 +244,17 @@ Requires-Dist: numpy<3,>=1.23
 Requires-Dist: packaging<25,>=20.9
 Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: platformdirs<5
-Requires-Dist: pyarrow
+Requires-Dist: pyarrow<19.0.0
 Requires-Dist: pydantic<3,>=2.8.2
 Requires-Dist: pyjwt<3,>=2.0.0
 Requires-Dist: pytimeparse<2,>=1.1.8
 Requires-Dist: pyyaml<7,>=6.0
 Requires-Dist: retrying<2,>=1.3.3
 Requires-Dist: s3fs<2026,>=2024.6.1
-Requires-Dist: scikit-learn<1.6
+Requires-Dist: scikit-learn<1.7
 Requires-Dist: scipy<2,>=1.9
 Requires-Dist: shap<1,>=0.46.0
-Requires-Dist: snowflake-connector-python[pandas]<4,>=3.15.0
+Requires-Dist: snowflake-connector-python[pandas]<4,>=3.16.0
 Requires-Dist: snowflake-snowpark-python!=1.26.0,<2,>=1.17.0
 Requires-Dist: snowflake.core<2,>=1.0.2
 Requires-Dist: sqlparse<1,>=0.4
@@ -410,7 +410,84 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.11.0
+## 1.13.0
+
+### Bug Fixes
+
+### Behavior Changes
+
+### New Features
+
+* Registry: Log a HuggingFace model without having to load the model in memory using
+ the `huggingface_pipeline.HuggingFacePipelineModel`. Requires `huggingface_hub` package to installed.
+ To disable downloading HuggingFace repository, provide `download_snapshot=False` while creating the
+ `huggingface_pipeline.HuggingFacePipelineModel` object.
+* Registry: Added support for XGBoost models to use `enable_categorical=True` with pandas DataFrame
+* Registry: Added support to display privatelink inference endpoint in ModelVersion list services.
+
+## 1.12.0
+
+### Bug Fixes
+
+* Registry: Fixed an issue where the string representation of dictionary-type output columns was being incorrectly
+  created during structured output deserialization. Now, the original data type is properly preserved.
+* Registry: Fixed the inference server performance issue for wide (500+ features) and JSON inputs.
+
+### Behavior Changes
+
+### New Features
+
+* Registry: Add OpenAI chat completion compatible signature option for `text-generation` models.
+
+```python
+from snowflake.ml.model import openai_signatures
+import pandas as pd
+
+mv = snowflake_registry.log_model(
+    model=generator,
+    model_name=...,
+    ...,
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+
+# create a pd.DataFrame with openai.client.chat.completions arguments like below:
+x_df = pd.DataFrame.from_records(
+    [
+        {
+            "messages": [
+                {"role": "system", "content": "Complete the sentence."},
+                {
+                    "role": "user",
+                    "content": "A descendant of the Lost City of Atlantis, who swam to Earth while saying, ",
+                },
+            ],
+            "max_completion_tokens": 250,
+            "temperature": 0.9,
+            "stop": None,
+            "n": 3,
+            "stream": False,
+            "top_p": 1.0,
+            "frequency_penalty": 0.1,
+            "presence_penalty": 0.2,
+        }
+    ],
+)
+
+# OpenAI Chat Completion compatible output
+output_df = mv.run(X=x_df)
+```
+
+* Model Monitoring: Added support for segment columns to enable filtered analysis.
+  * Added `segment_columns` parameter to `ModelMonitorSourceConfig` to specify columns for segmenting monitoring data
+  * Segment columns must be of STRING type and exist in the source table
+  * Added methods to dynamically manage segments:
+    * `add_segment_column()`: Add a new segment column to an existing monitor
+    * `drop_segment_column()`: Remove a segment column from an existing monitor
+* Experiment Tracking (PrPr): Support for logging artifacts (files and directories) with `log_artifact`
+* Experiment Tracking (PrPr): Support for listing artifacts in a run with `list_artifacts`
+* Experiment Tracking (PrPr): Support for downloading artifacts in a run with `download_artifacts`
+
+## 1.11.0 (08-12-2025)
 
 ### Bug Fixes