snowflake-ml-python 1.8.6__py3-none-any.whl → 1.9.1__py3-none-any.whl

snowflake/ml/modeling/metrics/regression.py

@@ -29,7 +29,7 @@ def d2_absolute_error_score(
     y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
-) -> Union[float, npt.NDArray[np.float_]]:
+) -> Union[float, npt.NDArray[np.float64]]:
     """
     :math:`D^2` regression score function, \
     fraction of absolute error explained.
@@ -111,7 +111,7 @@ def d2_absolute_error_score(
 
     kwargs = telemetry.get_sproc_statement_params_kwargs(d2_absolute_error_score_anon_sproc, statement_params)
     result_object = result.deserialize(session, d2_absolute_error_score_anon_sproc(session, **kwargs))
-    score: Union[float, npt.NDArray[np.float_]] = result_object
+    score: Union[float, npt.NDArray[np.float64]] = result_object
     return score
 
 
@@ -124,7 +124,7 @@ def d2_pinball_score(
     sample_weight_col_name: Optional[str] = None,
     alpha: float = 0.5,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
-) -> Union[float, npt.NDArray[np.float_]]:
+) -> Union[float, npt.NDArray[np.float64]]:
     """
     :math:`D^2` regression score function, fraction of pinball loss explained.
 
@@ -211,7 +211,7 @@ def d2_pinball_score(
     kwargs = telemetry.get_sproc_statement_params_kwargs(d2_pinball_score_anon_sproc, statement_params)
     result_object = result.deserialize(session, d2_pinball_score_anon_sproc(session, **kwargs))
 
-    score: Union[float, npt.NDArray[np.float_]] = result_object
+    score: Union[float, npt.NDArray[np.float64]] = result_object
     return score
 
 
@@ -224,7 +224,7 @@ def explained_variance_score(
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
     force_finite: bool = True,
-) -> Union[float, npt.NDArray[np.float_]]:
+) -> Union[float, npt.NDArray[np.float64]]:
     """
     Explained variance regression score function.
 
@@ -326,7 +326,7 @@ def explained_variance_score(
 
     kwargs = telemetry.get_sproc_statement_params_kwargs(explained_variance_score_anon_sproc, statement_params)
     result_object = result.deserialize(session, explained_variance_score_anon_sproc(session, **kwargs))
-    score: Union[float, npt.NDArray[np.float_]] = result_object
+    score: Union[float, npt.NDArray[np.float64]] = result_object
     return score
 
 
@@ -338,7 +338,7 @@ def mean_absolute_error(
     y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
-) -> Union[float, npt.NDArray[np.float_]]:
+) -> Union[float, npt.NDArray[np.float64]]:
     """
     Mean absolute error regression loss.
 
@@ -411,7 +411,7 @@ def mean_absolute_percentage_error(
     y_pred_col_names: Union[str, list[str]],
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
-) -> Union[float, npt.NDArray[np.float_]]:
+) -> Union[float, npt.NDArray[np.float64]]:
     """
     Mean absolute percentage error (MAPE) regression loss.
 
@@ -495,7 +495,7 @@ def mean_squared_error(
     sample_weight_col_name: Optional[str] = None,
     multioutput: Union[str, npt.ArrayLike] = "uniform_average",
     squared: bool = True,
-) -> Union[float, npt.NDArray[np.float_]]:
+) -> Union[float, npt.NDArray[np.float64]]:
     """
     Mean squared error regression loss.
 

snowflake/ml/monitoring/explain_visualize.py

@@ -264,6 +264,7 @@ def plot_force(
 def plot_influence_sensitivity(
     shap_values: type_hints.SupportedDataType,
     feature_values: type_hints.SupportedDataType,
+    infer_is_categorical: bool = True,
     figsize: tuple[float, float] = DEFAULT_FIGSIZE,
 ) -> Any:
     """
@@ -274,6 +275,8 @@ def plot_influence_sensitivity(
     Args:
         shap_values: pandas Series or 2D array containing the SHAP values for a specific feature
         feature_values: pandas Series or 2D array containing the feature values for the same feature
+        infer_is_categorical: If True, the function will infer if the feature is categorical
+            based on the number of unique values.
         figsize: tuple of (width, height) for the plot
 
     Returns:
@@ -294,7 +297,7 @@ def plot_influence_sensitivity(
     elif feature_values_df.shape[0] != shap_values_df.shape[0]:
         raise ValueError("Feature values and SHAP values must have the same number of rows.")
 
-    scatter = _create_scatter_plot(feature_values, shap_values, figsize)
+    scatter = _create_scatter_plot(feature_values, shap_values, infer_is_categorical, figsize)
     return st.altair_chart(scatter) if use_streamlit else scatter
 
 
@@ -322,11 +325,13 @@ def _prepare_feature_values_for_streamlit(
     return feature_values, shap_values, st
 
 
-def _create_scatter_plot(feature_values: pd.Series, shap_values: pd.Series, figsize: tuple[float, float]) -> alt.Chart:
+def _create_scatter_plot(
+    feature_values: pd.Series, shap_values: pd.Series, infer_is_categorical: bool, figsize: tuple[float, float]
+) -> alt.Chart:
     unique_vals = np.sort(np.unique(feature_values.values))
     max_points_per_unique_value = float(np.max(np.bincount(np.searchsorted(unique_vals, feature_values.values))))
     points_per_value = len(feature_values.values) / len(unique_vals)
-    is_categorical = float(max(max_points_per_unique_value, points_per_value)) > 10
+    is_categorical = float(max(max_points_per_unique_value, points_per_value)) > 10 if infer_is_categorical else False
 
     kwargs = (
         {
@@ -403,9 +408,11 @@ def plot_violin(
         .transform_density(density="shap_value", groupby=["feature_name"], as_=["shap_value", "density"])
         .mark_area(orient="vertical")
         .encode(
-            y=alt.Y("density:Q", title=None).stack("center").impute(None).axis(labels=False, grid=False, ticks=True),
+            y=alt.Y("density:Q", title=None).stack("center").impute(None).axis(labels=False, grid=False, ticks=False),
             x=alt.X("shap_value:Q", title="SHAP Value"),
-            row=alt.Row("feature_name:N", sort=column_sort_order).spacing(0),
+            row=alt.Row(
+                "feature_name:N", sort=column_sort_order, header=alt.Header(labelAngle=0, labelAlign="left")
+            ).spacing(0),
             color=alt.Color("feature_name:N", legend=None),
             tooltip=["feature_name", "shap_value"],
         )

snowflake/ml/registry/_manager/model_manager.py

@@ -1,5 +1,5 @@
 from types import ModuleType
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import pandas as pd
 from absl.logging import logging
@@ -8,7 +8,7 @@ from snowflake.ml._internal import env, 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, type_hints as model_types
+from snowflake.ml.model import model_signature, target_platform, 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
@@ -17,6 +17,9 @@ from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
 from snowflake.snowpark._internal import utils as snowpark_utils
 
+if TYPE_CHECKING:
+    from snowflake.ml.experiment._experiment_info import ExperimentInfo
+
 logger = logging.getLogger(__name__)
 
 
@@ -41,7 +44,7 @@ class ModelManager:
     def log_model(
         self,
         *,
-        model: Union[model_types.SupportedModelType, model_version_impl.ModelVersion],
+        model: Union[type_hints.SupportedModelType, model_version_impl.ModelVersion],
         model_name: str,
         version_name: Optional[str] = None,
         comment: Optional[str] = None,
@@ -50,16 +53,18 @@ class ModelManager:
         pip_requirements: Optional[list[str]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         resource_constraint: Optional[dict[str, str]] = None,
-        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
-        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        sample_input_data: Optional[type_hints.SupportedDataType] = None,
         user_files: Optional[dict[str, list[str]]] = None,
         code_paths: Optional[list[str]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        task: model_types.Task = model_types.Task.UNKNOWN,
-        options: Optional[model_types.ModelSaveOption] = None,
+        task: type_hints.Task = task.Task.UNKNOWN,
+        experiment_info: Optional["ExperimentInfo"] = None,
+        options: Optional[type_hints.ModelSaveOption] = None,
         statement_params: Optional[dict[str, Any]] = None,
+        progress_status: Optional[Any] = None,
     ) -> model_version_impl.ModelVersion:
 
         database_name_id, schema_name_id, model_name_id = self._parse_fully_qualified_name(model_name)
@@ -141,13 +146,15 @@ class ModelManager:
             code_paths=code_paths,
             ext_modules=ext_modules,
             task=task,
+            experiment_info=experiment_info,
             options=options,
             statement_params=statement_params,
+            progress_status=progress_status,
         )
 
     def _log_model(
         self,
-        model: model_types.SupportedModelType,
+        model: type_hints.SupportedModelType,
         *,
         model_name: str,
         version_name: str,
@@ -157,16 +164,18 @@ class ModelManager:
         pip_requirements: Optional[list[str]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         resource_constraint: Optional[dict[str, str]] = None,
-        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
-        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        sample_input_data: Optional[type_hints.SupportedDataType] = None,
         user_files: Optional[dict[str, list[str]]] = None,
         code_paths: Optional[list[str]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        task: model_types.Task = model_types.Task.UNKNOWN,
-        options: Optional[model_types.ModelSaveOption] = None,
+        task: type_hints.Task = task.Task.UNKNOWN,
+        experiment_info: Optional["ExperimentInfo"] = None,
+        options: Optional[type_hints.ModelSaveOption] = None,
         statement_params: Optional[dict[str, Any]] = None,
+        progress_status: Optional[Any] = None,
     ) -> model_version_impl.ModelVersion:
         database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
         version_name_id = sql_identifier.SqlIdentifier(version_name)
@@ -215,7 +224,7 @@ class ModelManager:
         # 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 = [model_types.TargetPlatform(platform) for platform in target_platforms]
+            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 (
@@ -231,7 +240,7 @@ class ModelManager:
                     "Logging a partitioned model with a table function without specifying `target_platforms`. "
                     'Default to `target_platforms=["WAREHOUSE"]`.'
                 )
-                platforms = [model_types.TargetPlatform.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:
@@ -239,7 +248,7 @@ class ModelManager:
                     "Logging the model on Container Runtime for ML without specifying `target_platforms`. "
                     'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'
                 )
-                platforms = [model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
+                platforms = [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
 
         if artifact_repository_map:
             for channel, artifact_repository_name in artifact_repository_map.items():
@@ -254,6 +263,9 @@ class ModelManager:
                 )
 
         logger.info("Start packaging and uploading your model. It might take some time based on the size of the model.")
+        if progress_status:
+            progress_status.update("packaging model...")
+            progress_status.increment()
 
         # Extract save_location from options if present
         save_location = None
@@ -267,6 +279,11 @@ class ModelManager:
             statement_params=statement_params,
             save_location=save_location,
         )
+
+        if progress_status:
+            progress_status.update("creating model manifest...")
+            progress_status.increment()
+
         model_metadata: model_meta.ModelMetadata = mc.save(
             name=model_name_id.resolved(),
             model=model,
@@ -283,7 +300,12 @@ class ModelManager:
             ext_modules=ext_modules,
             options=options,
             task=task,
+            experiment_info=experiment_info,
         )
+
+        if progress_status:
+            progress_status.update("uploading model files...")
+            progress_status.increment()
         statement_params = telemetry.add_statement_params_custom_tags(
             statement_params, model_metadata.telemetry_metadata()
         )
@@ -292,6 +314,9 @@ class ModelManager:
         )
 
         logger.info("Start creating MODEL object for you in the Snowflake.")
+        if progress_status:
+            progress_status.update("creating model object in Snowflake...")
+            progress_status.increment()
 
         self._model_ops.create_from_stage(
             composed_model=mc,
@@ -318,6 +343,10 @@ class ModelManager:
             version_name=version_name_id,
         )
 
+        if progress_status:
+            progress_status.update("setting model metadata...")
+            progress_status.increment()
+
         if comment:
             mv.comment = comment
 
@@ -331,6 +360,9 @@ class ModelManager:
                 statement_params=statement_params,
             )
 
+        if progress_status:
+            progress_status.update("model logged successfully!")
+
         return mv
 
     def get_model(

snowflake/ml/registry/registry.py

@@ -6,12 +6,15 @@ import pandas as pd
 
 from snowflake import snowpark
 from snowflake.ml._internal import telemetry
-from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml._internal.utils import query_result_checker, sql_identifier
 from snowflake.ml.model import (
     Model,
     ModelVersion,
+    event_handler,
     model_signature,
-    type_hints as model_types,
+    target_platform,
+    task,
+    type_hints,
 )
 from snowflake.ml.model._client.model import model_version_impl
 from snowflake.ml.monitoring import model_monitor
@@ -75,20 +78,30 @@ class Registry:
                 else sql_identifier.SqlIdentifier("PUBLIC")
             )
 
-        database_exists = session.sql(
-            f"""SELECT 1 FROM INFORMATION_SCHEMA.DATABASES WHERE DATABASE_NAME = '{self._database_name.resolved()}';"""
-        ).collect()
+        database_results = (
+            query_result_checker.SqlResultValidator(
+                session, f"""SHOW DATABASES LIKE '{self._database_name.resolved()}';"""
+            )
+            .has_column("name", allow_empty=True)
+            .validate()
+        )
 
-        if not database_exists:
+        db_names = [row["name"] for row in database_results]
+        if not self._database_name.resolved() in db_names:
             raise ValueError(f"Database {self._database_name} does not exist.")
 
-        schema_exists = session.sql(
-            f"""
-            SELECT 1 FROM {self._database_name.identifier()}.INFORMATION_SCHEMA.SCHEMATA
-            WHERE SCHEMA_NAME = '{self._schema_name.resolved()}';"""
-        ).collect()
+        schema_results = (
+            query_result_checker.SqlResultValidator(
+                session,
+                f"""SHOW SCHEMAS LIKE '{self._schema_name.resolved()}'
+                IN DATABASE {self._database_name.identifier()};""",
+            )
+            .has_column("name", allow_empty=True)
+            .validate()
+        )
 
-        if not schema_exists:
+        schema_names = [row["name"] for row in schema_results]
+        if not self._schema_name.resolved() in schema_names:
             raise ValueError(f"Schema {self._schema_name} does not exist.")
 
         self._model_manager = model_manager.ModelManager(
@@ -119,7 +132,7 @@ class Registry:
     @overload
     def log_model(
         self,
-        model: model_types.SupportedModelType,
+        model: type_hints.SupportedModelType,
         *,
         model_name: str,
         version_name: Optional[str] = None,
@@ -129,15 +142,15 @@ class Registry:
         pip_requirements: Optional[list[str]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         resource_constraint: Optional[dict[str, str]] = None,
-        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        target_platforms: Optional[list[Union[target_platform.TargetPlatform, str]]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
-        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        sample_input_data: Optional[type_hints.SupportedDataType] = None,
         user_files: Optional[dict[str, list[str]]] = None,
         code_paths: Optional[list[str]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        task: model_types.Task = model_types.Task.UNKNOWN,
-        options: Optional[model_types.ModelSaveOption] = None,
+        task: task.Task = task.Task.UNKNOWN,
+        options: Optional[type_hints.ModelSaveOption] = None,
     ) -> ModelVersion:
         """
         Log a model with various parameters and metadata, or a ModelVersion object.
@@ -159,12 +172,12 @@ class Registry:
                 to specify a dependency. It is a recommended way to specify your dependencies using conda. When channel
                 is not specified, Snowflake Anaconda Channel will be used. Defaults to None.
             pip_requirements: List of Pip package specifications. Defaults to None.
-                Models with pip requirements are currently only runnable in Snowpark Container Services.
-                See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
-                Models with pip requirements specified will not be executable in Snowflake Warehouse where all
-                dependencies must be retrieved from Snowflake Anaconda Channel.
+                Models running in a Snowflake Warehouse must also specify a pip artifact repository (see
+                `artifact_repository_map`). Otherwise, models with pip requirements are runnable only in Snowpark
+                Container Services. See
+                https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
             artifact_repository_map: Specifies a mapping of package channels or platforms to custom artifact
-                repositories. Defaults to None. Currently, the mapping applies only to warehouse execution.
+                repositories. Defaults to None. Currently, the mapping applies only to Warehouse execution.
                 Note : This feature is currently in Public Preview.
                 Format: {channel_name: artifact_repository_name}, where:
                    - channel_name: Currently must be 'pip'.
@@ -172,10 +185,13 @@ class Registry:
                      `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES":
-                - ["WAREHOUSE"]  (Warehouse only)
-                - ["SNOWPARK_CONTAINER_SERVICES"]  (Snowpark Container Services only)
-                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] (Both)
+                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES", or a target platform constant:
+                - ["WAREHOUSE"] or snowflake.ml.model.target_platform.WAREHOUSE_ONLY (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY
+                  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.BOTH_WAREHOUSE_AND_SNOWPARK_CONTAINER_SERVICES (Both)
                 Defaults to None. When None, the target platforms will be both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
@@ -206,7 +222,8 @@ class Registry:
                 - target_methods: List of target methods to register when logging the model.
                   This option is not used in MLFlow models. Defaults to None, in which case the model handler's
                   default target methods will be used.
-                - save_location: Location to save the model and metadata.
+                - save_location: Local directory to save the the serialized model files first before
+                  uploading to Snowflake. This is useful when default tmp directory is not writable.
                 - method_options: Per-method saving options. This dictionary has method names as keys and dictionary
                     values with the desired options.
 
@@ -263,7 +280,7 @@ class Registry:
     )
     def log_model(
         self,
-        model: Union[model_types.SupportedModelType, ModelVersion],
+        model: Union[type_hints.SupportedModelType, ModelVersion],
         *,
         model_name: str,
         version_name: Optional[str] = None,
@@ -273,15 +290,15 @@ class Registry:
         pip_requirements: Optional[list[str]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         resource_constraint: Optional[dict[str, str]] = None,
-        target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
+        target_platforms: Optional[list[Union[target_platform.TargetPlatform, str]]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
-        sample_input_data: Optional[model_types.SupportedDataType] = None,
+        sample_input_data: Optional[type_hints.SupportedDataType] = None,
         user_files: Optional[dict[str, list[str]]] = None,
         code_paths: Optional[list[str]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        task: model_types.Task = model_types.Task.UNKNOWN,
-        options: Optional[model_types.ModelSaveOption] = None,
+        task: task.Task = task.Task.UNKNOWN,
+        options: Optional[type_hints.ModelSaveOption] = None,
     ) -> ModelVersion:
         """
         Log a model with various parameters and metadata, or a ModelVersion object.
@@ -303,12 +320,12 @@ class Registry:
                 to specify a dependency. It is a recommended way to specify your dependencies using conda. When channel
                 is not specified, Snowflake Anaconda Channel will be used. Defaults to None.
             pip_requirements: List of Pip package specifications. Defaults to None.
-                Models with pip requirements are currently only runnable in Snowpark Container Services.
-                See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
-                Models with pip requirements specified will not be executable in Snowflake Warehouse where all
-                dependencies must be retrieved from Snowflake Anaconda Channel.
+                Models running in a Snowflake Warehouse must also specify a pip artifact repository (see
+                `artifact_repository_map`). Otherwise, models with pip requirements are runnable only in Snowpark
+                Container Services. See
+                https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
             artifact_repository_map: Specifies a mapping of package channels or platforms to custom artifact
-                repositories. Defaults to None. Currently, the mapping applies only to warehouse execution.
+                repositories. Defaults to None. Currently, the mapping applies only to Warehouse execution.
                 Note : This feature is currently in Public Preview.
                 Format: {channel_name: artifact_repository_name}, where:
                    - channel_name: Currently must be 'pip'.
@@ -316,10 +333,13 @@ class Registry:
                      `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES":
-                - ["WAREHOUSE"]  (Warehouse only)
-                - ["SNOWPARK_CONTAINER_SERVICES"]  (Snowpark Container Services only)
-                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] (Both)
+                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES", or a target platform constant:
+                - ["WAREHOUSE"] or snowflake.ml.model.target_platform.WAREHOUSE_ONLY (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY
+                  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] or
+                  snowflake.ml.model.target_platform.BOTH_WAREHOUSE_AND_SNOWPARK_CONTAINER_SERVICES (Both)
                 Defaults to None. When None, the target platforms will be both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
@@ -366,6 +386,7 @@ class Registry:
 
         Raises:
             ValueError: If extra arguments are specified ModelVersion is provided.
+            Exception: If the model logging fails.
 
         Returns:
             ModelVersion: ModelVersion object corresponding to the model just logged.
@@ -418,10 +439,10 @@ class Registry:
                     raise ValueError(
                         "When calling log_model with a ModelVersion, only model_name and version_name may be specified."
                     )
-            if task is not model_types.Task.UNKNOWN:
+            if task is not type_hints.Task.UNKNOWN:
                 raise ValueError("`task` cannot be specified when calling log_model with a ModelVersion.")
 
-        if pip_requirements and not artifact_repository_map:
+        if pip_requirements and not artifact_repository_map and self._targets_warehouse(target_platforms):
             warnings.warn(
                 "Models logged specifying `pip_requirements` cannot be executed in a Snowflake Warehouse "
                 "without specifying `artifact_repository_map`. This model can be run in Snowpark Container "
@@ -429,27 +450,42 @@ class Registry:
                 category=UserWarning,
                 stacklevel=1,
             )
-        return self._model_manager.log_model(
-            model=model,
-            model_name=model_name,
-            version_name=version_name,
-            comment=comment,
-            metrics=metrics,
-            conda_dependencies=conda_dependencies,
-            pip_requirements=pip_requirements,
-            artifact_repository_map=artifact_repository_map,
-            resource_constraint=resource_constraint,
-            target_platforms=target_platforms,
-            python_version=python_version,
-            signatures=signatures,
-            sample_input_data=sample_input_data,
-            user_files=user_files,
-            code_paths=code_paths,
-            ext_modules=ext_modules,
-            task=task,
-            options=options,
-            statement_params=statement_params,
-        )
+
+        registry_event_handler = event_handler.ModelEventHandler()
+        with registry_event_handler.status("Logging model", total=6) as status:
+            # Step 1: Validation and setup
+            status.update("validating model and dependencies...")
+            status.increment()
+
+            # Perform the actual model logging
+            try:
+                result = self._model_manager.log_model(
+                    model=model,
+                    model_name=model_name,
+                    version_name=version_name,
+                    comment=comment,
+                    metrics=metrics,
+                    conda_dependencies=conda_dependencies,
+                    pip_requirements=pip_requirements,
+                    artifact_repository_map=artifact_repository_map,
+                    resource_constraint=resource_constraint,
+                    target_platforms=target_platforms,
+                    python_version=python_version,
+                    signatures=signatures,
+                    sample_input_data=sample_input_data,
+                    user_files=user_files,
+                    code_paths=code_paths,
+                    ext_modules=ext_modules,
+                    task=task,
+                    options=options,
+                    statement_params=statement_params,
+                    progress_status=status,
+                )
+                status.update(label="Model logged successfully.", state="complete", expanded=False)
+                return result
+            except Exception as e:
+                status.update(label="Model logging failed.", state="error", expanded=False)
+                raise e
 
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
@@ -626,3 +662,12 @@ class Registry:
         if not self.enable_monitoring:
             raise ValueError(_MODEL_MONITORING_DISABLED_ERROR)
         self._model_monitor_manager.delete_monitor(name)
+
+    @staticmethod
+    def _targets_warehouse(target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]]) -> bool:
+        """Returns True if warehouse is a target platform (None defaults to True)."""
+        return (
+            target_platforms is None
+            or type_hints.TargetPlatform.WAREHOUSE in target_platforms
+            or "WAREHOUSE" in target_platforms
+        )

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.8.6"
+VERSION = "1.9.1"