snowflake-ml-python 1.10.0__py3-none-any.whl → 1.12.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/registry/_manager/model_manager.py

@@ -4,15 +4,14 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 import pandas as pd
 from absl.logging import logging
 
-from snowflake.ml._internal import env, platform_capabilities, telemetry
+from snowflake.ml._internal import platform_capabilities, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions
 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, target_platform, task, type_hints
+from snowflake.ml.model import model_signature, task, type_hints
 from snowflake.ml.model._client.model import model_impl, model_version_impl
 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._model_composer.model_manifest import model_manifest_schema
 from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.ml.registry._manager import model_parameter_reconciler
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
@@ -221,37 +220,8 @@ class ModelManager:
                 statement_params=statement_params,
             )
 
-        platforms = None
-        # User specified target platforms are defaulted to None and will not show up in the generated manifest.
-        if target_platforms:
-            # Convert any string target platforms to TargetPlatform objects
-            platforms = [type_hints.TargetPlatform(platform) for platform in target_platforms]
-        else:
-            # Default the target platform to warehouse if not specified and any table function exists
-            if options and (
-                options.get("function_type") == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value
-                or (
-                    any(
-                        opt.get("function_type") == "TABLE_FUNCTION"
-                        for opt in options.get("method_options", {}).values()
-                    )
-                )
-            ):
-                logger.info(
-                    "Logging a partitioned model with a table function without specifying `target_platforms`. "
-                    'Default to `target_platforms=["WAREHOUSE"]`.'
-                )
-                platforms = [target_platform.TargetPlatform.WAREHOUSE]
-
-            # Default the target platform to SPCS if not specified when running in ML runtime
-            if not platforms and env.IN_ML_RUNTIME:
-                logger.info(
-                    "Logging the model on Container Runtime for ML without specifying `target_platforms`. "
-                    'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'
-                )
-                platforms = [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
-
         reconciler = model_parameter_reconciler.ModelParameterReconciler(
+            session=self._model_ops._session,
             database_name=self._database_name,
             schema_name=self._schema_name,
             conda_dependencies=conda_dependencies,
@@ -259,6 +229,8 @@ class ModelManager:
             target_platforms=target_platforms,
             artifact_repository_map=artifact_repository_map,
             options=options,
+            python_version=python_version,
+            statement_params=statement_params,
         )
 
         model_params = reconciler.reconcile()
@@ -293,12 +265,12 @@ class ModelManager:
             pip_requirements=pip_requirements,
             artifact_repository_map=artifact_repository_map,
             resource_constraint=resource_constraint,
-            target_platforms=platforms,
+            target_platforms=model_params.target_platforms,
             python_version=python_version,
             user_files=user_files,
             code_paths=code_paths,
             ext_modules=ext_modules,
-            options=options,
+            options=model_params.options,
             task=task,
             experiment_info=experiment_info,
         )

snowflake/ml/registry/_manager/model_parameter_reconciler.py

@@ -1,9 +1,20 @@
 import warnings
 from dataclasses import dataclass
-from typing import Optional
+from typing import Any, Optional
 
+from absl.logging import logging
+from packaging import requirements
+
+from snowflake.ml import version as snowml_version
+from snowflake.ml._internal import env, env as snowml_env, env_utils
+from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.model import type_hints as model_types
+from snowflake.ml.model import target_platform, type_hints as model_types
+from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
+from snowflake.snowpark import Session
+from snowflake.snowpark._internal import utils as snowpark_utils
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -12,7 +23,7 @@ class ReconciledParameters:
 
     conda_dependencies: Optional[list[str]] = None
     pip_requirements: Optional[list[str]] = None
-    target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None
+    target_platforms: Optional[list[model_types.TargetPlatform]] = None
     artifact_repository_map: Optional[dict[str, str]] = None
     options: Optional[model_types.ModelSaveOption] = None
     save_location: Optional[str] = None
@@ -23,6 +34,7 @@ class ModelParameterReconciler:
 
     def __init__(
         self,
+        session: Session,
         database_name: sql_identifier.SqlIdentifier,
         schema_name: sql_identifier.SqlIdentifier,
         conda_dependencies: Optional[list[str]] = None,
@@ -30,7 +42,10 @@ class ModelParameterReconciler:
         target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         options: Optional[model_types.ModelSaveOption] = None,
+        python_version: Optional[str] = None,
+        statement_params: Optional[dict[str, str]] = None,
     ) -> None:
+        self._session = session
         self._database_name = database_name
         self._schema_name = schema_name
         self._conda_dependencies = conda_dependencies
@@ -38,20 +53,27 @@ class ModelParameterReconciler:
         self._target_platforms = target_platforms
         self._artifact_repository_map = artifact_repository_map
         self._options = options
+        self._python_version = python_version
+        self._statement_params = statement_params
 
     def reconcile(self) -> ReconciledParameters:
         """Perform all parameter reconciliation and return clean parameters."""
+
         reconciled_artifact_repository_map = self._reconcile_artifact_repository_map()
         reconciled_save_location = self._extract_save_location()
 
         self._validate_pip_requirements_warehouse_compatibility(reconciled_artifact_repository_map)
 
+        reconciled_target_platforms = self._reconcile_target_platforms()
+        reconciled_options = self._reconcile_explainability_options(reconciled_target_platforms)
+        reconciled_options = self._reconcile_relax_version(reconciled_options, reconciled_target_platforms)
+
         return ReconciledParameters(
             conda_dependencies=self._conda_dependencies,
             pip_requirements=self._pip_requirements,
-            target_platforms=self._target_platforms,
+            target_platforms=reconciled_target_platforms,
             artifact_repository_map=reconciled_artifact_repository_map,
-            options=self._options,
+            options=reconciled_options,
             save_location=reconciled_save_location,
         )
 
@@ -82,6 +104,45 @@ class ModelParameterReconciler:
 
         return None
 
+    def _reconcile_target_platforms(self) -> Optional[list[model_types.TargetPlatform]]:
+        """Reconcile target platforms with proper defaulting logic."""
+        # User specified target platforms are defaulted to None and will not show up in the generated manifest.
+        if self._target_platforms:
+            # Convert any string target platforms to TargetPlatform objects
+            return [model_types.TargetPlatform(platform) for platform in self._target_platforms]
+
+        # Default the target platform to warehouse if not specified and any table function exists
+        if self._has_table_function():
+            logger.info(
+                "Logging a partitioned model with a table function without specifying `target_platforms`. "
+                'Default to `target_platforms=["WAREHOUSE"]`.'
+            )
+            return [target_platform.TargetPlatform.WAREHOUSE]
+
+        # Default the target platform to SPCS if not specified when running in ML runtime
+        if env.IN_ML_RUNTIME:
+            logger.info(
+                "Logging the model on Container Runtime for ML without specifying `target_platforms`. "
+                'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'
+            )
+            return [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
+
+        return None
+
+    def _has_table_function(self) -> bool:
+        """Check if any table function exists in options."""
+        if self._options is None:
+            return False
+
+        if self._options.get("function_type") == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value:
+            return True
+
+        for opt in self._options.get("method_options", {}).values():
+            if opt.get("function_type") == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value:
+                return True
+
+        return False
+
     def _validate_pip_requirements_warehouse_compatibility(
         self, artifact_repository_map: Optional[dict[str, str]]
     ) -> None:
@@ -103,3 +164,131 @@ class ModelParameterReconciler:
             or model_types.TargetPlatform.WAREHOUSE in target_platforms
             or "WAREHOUSE" in target_platforms
         )
+
+    def _reconcile_explainability_options(
+        self, target_platforms: Optional[list[model_types.TargetPlatform]]
+    ) -> model_types.ModelSaveOption:
+        """Reconcile explainability settings and embed_local_ml_library based on warehouse runnability."""
+        options = self._options.copy() if self._options else model_types.BaseModelSaveOption()
+
+        conda_dep_dict = env_utils.validate_conda_dependency_string_list(self._conda_dependencies or [])
+
+        enable_explainability = options.get("enable_explainability", None)
+
+        # Handle case where user explicitly disabled explainability
+        if enable_explainability is False:
+            return self._handle_embed_local_ml_library(options, target_platforms)
+
+        target_platform_set = set(target_platforms) if target_platforms else set()
+
+        is_warehouse_runnable = self._is_warehouse_runnable(conda_dep_dict)
+        only_spcs = target_platform_set == set(target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY)
+        has_both_platforms = target_platform_set == set(target_platform.BOTH_WAREHOUSE_AND_SNOWPARK_CONTAINER_SERVICES)
+
+        # Handle case where user explicitly requested explainability
+        if enable_explainability:
+            if only_spcs or not is_warehouse_runnable:
+                raise ValueError(
+                    "`enable_explainability` cannot be set to True when the model is not runnable in WH "
+                    "or the target platforms include SPCS."
+                )
+            elif has_both_platforms:
+                warnings.warn(
+                    ("Explain function will only be available for model deployed to warehouse."),
+                    category=UserWarning,
+                    stacklevel=2,
+                )
+
+        # Handle case where explainability is not specified (None) - set default behavior
+        if enable_explainability is None:
+            if only_spcs or not is_warehouse_runnable:
+                options["enable_explainability"] = False
+
+        return self._handle_embed_local_ml_library(options, target_platforms)
+
+    def _handle_embed_local_ml_library(
+        self, options: model_types.ModelSaveOption, target_platforms: Optional[list[model_types.TargetPlatform]]
+    ) -> model_types.ModelSaveOption:
+        """Handle embed_local_ml_library logic."""
+        if not snowpark_utils.is_in_stored_procedure() and target_platforms != [  # type: ignore[no-untyped-call]
+            model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES  # no information schema check for SPCS-only models
+        ]:
+            snowml_matched_versions = env_utils.get_matched_package_versions_in_information_schema(
+                self._session,
+                reqs=[requirements.Requirement(f"{env_utils.SNOWPARK_ML_PKG_NAME}=={snowml_version.VERSION}")],
+                python_version=self._python_version or snowml_env.PYTHON_VERSION,
+                statement_params=self._statement_params,
+            ).get(env_utils.SNOWPARK_ML_PKG_NAME, [])
+
+            if len(snowml_matched_versions) < 1 and not options.get("embed_local_ml_library", False):
+                logging.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."
+                )
+                options["embed_local_ml_library"] = True
+
+        return options
+
+    def _is_warehouse_runnable(self, conda_dep_dict: dict[str, list[Any]]) -> bool:
+        """Check if model can run in warehouse based on conda channels and pip requirements."""
+        # If pip requirements are present but no artifact repository map, model cannot run in warehouse
+        if self._pip_requirements and not self._artifact_repository_map:
+            return False
+
+        # If no conda dependencies, model can run in warehouse
+        if not conda_dep_dict:
+            return True
+
+        # Check if all conda channels are warehouse-compatible
+        warehouse_compatible_channels = {env_utils.DEFAULT_CHANNEL_NAME, env_utils.SNOWFLAKE_CONDA_CHANNEL_URL}
+        for channel in conda_dep_dict:
+            if channel not in warehouse_compatible_channels:
+                return False
+
+        return True
+
+    def _reconcile_relax_version(
+        self,
+        options: model_types.ModelSaveOption,
+        target_platforms: Optional[list[model_types.TargetPlatform]],
+    ) -> model_types.ModelSaveOption:
+        """Reconcile relax_version setting based on pip requirements and target platforms."""
+        target_platform_set = set(target_platforms) if target_platforms else set()
+        has_pip_requirements = bool(self._pip_requirements)
+        only_spcs = target_platform_set == set(target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY)
+
+        if "relax_version" not in options:
+            if has_pip_requirements or only_spcs:
+                logger.info(
+                    "Setting `relax_version=False` as this model will run in Snowpark Container Services "
+                    "or in Warehouse with a specified artifact_repository_map where exact version "
+                    " specifications will be honored."
+                )
+                relax_version = False
+            else:
+                warnings.warn(
+                    (
+                        "`relax_version` is not set and therefore defaulted to True. Dependency version constraints"
+                        " relaxed from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility,"
+                        " reproducibility, etc., set `options={'relax_version': False}` when logging the model."
+                    ),
+                    category=UserWarning,
+                    stacklevel=2,
+                )
+                relax_version = True
+            options["relax_version"] = relax_version
+            return options
+
+        # Handle case where relax_version is already set
+        relax_version = options["relax_version"]
+        if relax_version and (has_pip_requirements or only_spcs):
+            raise exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    "Setting `relax_version=True` is only allowed for models to be run in Warehouse with "
+                    "Snowflake Conda Channel dependencies. It cannot be used with pip requirements or when "
+                    "targeting only Snowpark Container Services."
+                ),
+            )
+
+        return options

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.10.0"
+VERSION = "1.12.0"