snowflake-ml-python 1.6.2__py3-none-any.whl → 1.6.3__py3-none-any.whl

snowflake/ml/modeling/pipeline/pipeline.py

@@ -379,7 +379,6 @@ class Pipeline(base.BaseTransformer):
                 anonymous=True,
                 imports=imports,  # type: ignore[arg-type]
                 statement_params=sproc_statement_params,
-                execute_as="caller",
             )
 
             sproc_export_file_name: str = pipeline_within_one_sproc(

snowflake/ml/modeling/preprocessing/polynomial_features.py

@@ -535,6 +535,7 @@ class PolynomialFeatures(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/semi_supervised/label_propagation.py

@@ -537,6 +537,7 @@ class LabelPropagation(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/semi_supervised/label_spreading.py

@@ -546,6 +546,7 @@ class LabelSpreading(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/svm/linear_svc.py

@@ -602,6 +602,7 @@ class LinearSVC(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/svm/linear_svr.py

@@ -574,6 +574,7 @@ class LinearSVR(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/svm/nu_svc.py

@@ -608,6 +608,7 @@ class NuSVC(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/svm/nu_svr.py

@@ -569,6 +569,7 @@ class NuSVR(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/svm/svc.py

@@ -611,6 +611,7 @@ class SVC(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/svm/svr.py

@@ -572,6 +572,7 @@ class SVR(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/tree/decision_tree_classifier.py

@@ -639,6 +639,7 @@ class DecisionTreeClassifier(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/tree/decision_tree_regressor.py

@@ -621,6 +621,7 @@ class DecisionTreeRegressor(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/tree/extra_tree_classifier.py

@@ -631,6 +631,7 @@ class ExtraTreeClassifier(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/tree/extra_tree_regressor.py

@@ -613,6 +613,7 @@ class ExtraTreeRegressor(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/xgboost/xgb_classifier.py

@@ -732,6 +732,7 @@ class XGBClassifier(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/xgboost/xgb_regressor.py

@@ -731,6 +731,7 @@ class XGBRegressor(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/xgboost/xgbrf_classifier.py

@@ -736,6 +736,7 @@ class XGBRFClassifier(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/modeling/xgboost/xgbrf_regressor.py

@@ -736,6 +736,7 @@ class XGBRFRegressor(BaseTransformer):
         """
         self._infer_input_output_cols(dataset)
         super()._check_dataset_type(dataset)
+
         model_trainer = ModelTrainerBuilder.build_fit_transform(
             estimator=self._sklearn_object,
             dataset=dataset,

snowflake/ml/monitoring/_client/model_monitor.py

@@ -0,0 +1,126 @@
+from typing import List, Union
+
+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.monitoring._client import monitor_sql_client
+
+
+class ModelMonitor:
+    """Class to manage instrumentation of Model Monitoring and Observability"""
+
+    name: sql_identifier.SqlIdentifier
+    _model_monitor_client: monitor_sql_client._ModelMonitorSQLClient
+    _fully_qualified_model_name: str
+    _version_name: sql_identifier.SqlIdentifier
+    _function_name: sql_identifier.SqlIdentifier
+    _prediction_columns: List[sql_identifier.SqlIdentifier]
+    _label_columns: List[sql_identifier.SqlIdentifier]
+
+    def __init__(self) -> None:
+        raise RuntimeError("ModelMonitor's initializer is not meant to be used.")
+
+    @classmethod
+    def _ref(
+        cls,
+        model_monitor_client: monitor_sql_client._ModelMonitorSQLClient,
+        name: sql_identifier.SqlIdentifier,
+        *,
+        fully_qualified_model_name: str,
+        version_name: sql_identifier.SqlIdentifier,
+        function_name: sql_identifier.SqlIdentifier,
+        prediction_columns: List[sql_identifier.SqlIdentifier],
+        label_columns: List[sql_identifier.SqlIdentifier],
+    ) -> "ModelMonitor":
+        self: "ModelMonitor" = object.__new__(cls)
+        self.name = name
+        self._model_monitor_client = model_monitor_client
+        self._fully_qualified_model_name = fully_qualified_model_name
+        self._version_name = version_name
+        self._function_name = function_name
+        self._prediction_columns = prediction_columns
+        self._label_columns = label_columns
+        return self
+
+    @telemetry.send_api_usage_telemetry(
+        project=telemetry.TelemetryProject.MLOPS.value,
+        subproject=telemetry.TelemetrySubProject.MONITORING.value,
+    )
+    def set_baseline(self, baseline_df: Union[pd.DataFrame, snowpark.DataFrame]) -> None:
+        """
+        The baseline dataframe is compared with the monitored data once monitoring is enabled.
+        The columns of the dataframe should match the columns of the source table that the
+        ModelMonitor was configured with. Calling this method overwrites any existing baseline split data.
+
+        Args:
+            baseline_df: Snowpark dataframe containing baseline data.
+
+        Raises:
+            ValueError: baseline_df does not contain prediction or label columns
+        """
+        statement_params = telemetry.get_statement_params(
+            project=telemetry.TelemetryProject.MLOPS.value,
+            subproject=telemetry.TelemetrySubProject.MONITORING.value,
+        )
+
+        if isinstance(baseline_df, pd.DataFrame):
+            baseline_df = self._model_monitor_client._sql_client._session.create_dataframe(baseline_df)
+
+        column_names_identifiers: List[sql_identifier.SqlIdentifier] = [
+            sql_identifier.SqlIdentifier(column_name) for column_name in baseline_df.columns
+        ]
+        prediction_cols_not_found = any(
+            [prediction_col not in column_names_identifiers for prediction_col in self._prediction_columns]
+        )
+        label_cols_not_found = any(
+            [label_col.identifier() not in column_names_identifiers for label_col in self._label_columns]
+        )
+
+        if prediction_cols_not_found:
+            raise ValueError(
+                "Specified prediction columns were not found in the baseline dataframe. "
+                f"Columns provided were: {column_names_identifiers}. "
+                f"Configured prediction columns were: {self._prediction_columns}."
+            )
+        if label_cols_not_found:
+            raise ValueError(
+                "Specified label columns were not found in the baseline dataframe."
+                f"Columns provided in the baseline dataframe were: {column_names_identifiers}."
+                f"Configured label columns were: {self._label_columns}."
+            )
+
+        # Create the table by materializing the df
+        self._model_monitor_client.materialize_baseline_dataframe(
+            baseline_df,
+            self._fully_qualified_model_name,
+            self._version_name,
+            statement_params=statement_params,
+        )
+
+    def suspend(self) -> None:
+        """Suspend pipeline for ModelMonitor"""
+        statement_params = telemetry.get_statement_params(
+            telemetry.TelemetryProject.MLOPS.value,
+            telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        _, _, model_name = sql_identifier.parse_fully_qualified_name(self._fully_qualified_model_name)
+        self._model_monitor_client.suspend_monitor_dynamic_tables(
+            model_name=model_name,
+            version_name=self._version_name,
+            statement_params=statement_params,
+        )
+
+    def resume(self) -> None:
+        """Resume pipeline for ModelMonitor"""
+        statement_params = telemetry.get_statement_params(
+            telemetry.TelemetryProject.MLOPS.value,
+            telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        _, _, model_name = sql_identifier.parse_fully_qualified_name(self._fully_qualified_model_name)
+        self._model_monitor_client.resume_monitor_dynamic_tables(
+            model_name=model_name,
+            version_name=self._version_name,
+            statement_params=statement_params,
+        )

snowflake/ml/monitoring/_client/model_monitor_manager.py

@@ -0,0 +1,361 @@
+from typing import Any, Dict, List, Optional
+
+from snowflake import snowpark
+from snowflake.ml._internal import telemetry
+from snowflake.ml._internal.utils import db_utils, sql_identifier
+from snowflake.ml.model import type_hints
+from snowflake.ml.model._client.model import model_version_impl
+from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
+from snowflake.ml.monitoring._client import model_monitor, monitor_sql_client
+from snowflake.ml.monitoring.entities import (
+    model_monitor_config,
+    model_monitor_interval,
+)
+from snowflake.snowpark import session
+
+
+def _validate_name_constraints(model_version: model_version_impl.ModelVersion) -> None:
+    system_table_prefixes = [
+        monitor_sql_client._SNOWML_MONITORING_TABLE_NAME_PREFIX,
+        monitor_sql_client._SNOWML_MONITORING_ACCURACY_TABLE_NAME_PREFIX,
+    ]
+
+    max_allowed_model_name_and_version_length = (
+        db_utils.MAX_IDENTIFIER_LENGTH - max(len(prefix) for prefix in system_table_prefixes) - 1
+    )  # -1 includes '_' between model_name + model_version
+    if len(model_version.model_name) + len(model_version.version_name) > max_allowed_model_name_and_version_length:
+        error_msg = f"Model name and version name exceeds maximum length of {max_allowed_model_name_and_version_length}"
+        raise ValueError(error_msg)
+
+
+class ModelMonitorManager:
+    """Class to manage internal operations for Model Monitor workflows."""  # TODO: Move to Registry.
+
+    @staticmethod
+    def setup(session: session.Session, database_name: str, schema_name: str) -> None:
+        """Static method to set up schema for Model Monitoring resources.
+
+        Args:
+            session: The Snowpark Session to connect with Snowflake.
+            database_name: The name of the database. If None, the current database of the session
+                will be used. Defaults to None.
+            schema_name: The name of the schema. If None, the current schema of the session
+                will be used. If there is no active schema, the PUBLIC schema will be used. Defaults to None.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=telemetry.TelemetryProject.MLOPS.value,
+            subproject=telemetry.TelemetrySubProject.MONITORING.value,
+        )
+        database_name_id = sql_identifier.SqlIdentifier(database_name)
+        schema_name_id = sql_identifier.SqlIdentifier(schema_name)
+        monitor_sql_client._ModelMonitorSQLClient.initialize_monitoring_schema(
+            session, database_name_id, schema_name_id, statement_params=statement_params
+        )
+
+    def _fetch_task_from_model_version(
+        self,
+        model_version: model_version_impl.ModelVersion,
+    ) -> type_hints.Task:
+        task = model_version.get_model_task()
+        if task == type_hints.Task.UNKNOWN:
+            raise ValueError("Registry model must be logged with task in order to be monitored.")
+        return task
+
+    def __init__(
+        self,
+        session: session.Session,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+        *,
+        create_if_not_exists: bool = False,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Opens a ModelMonitorManager for a given database and schema.
+        Optionally sets up the schema for Model Monitoring.
+
+        Args:
+            session: The Snowpark Session to connect with Snowflake.
+            database_name: The name of the database.
+            schema_name: The name of the schema.
+            create_if_not_exists: Flag whether to initialize resources in the schema needed for Model Monitoring.
+            statement_params: Optional set of statement params.
+
+        Raises:
+            ValueError: When there is no specified or active database in the session.
+        """
+        self._database_name = database_name
+        self._schema_name = schema_name
+        self.statement_params = statement_params
+        self._model_monitor_client = monitor_sql_client._ModelMonitorSQLClient(
+            session,
+            database_name=self._database_name,
+            schema_name=self._schema_name,
+        )
+        if create_if_not_exists:
+            monitor_sql_client._ModelMonitorSQLClient.initialize_monitoring_schema(
+                session, self._database_name, self._schema_name, self.statement_params
+            )
+        elif not self._model_monitor_client._validate_is_initialized():
+            raise ValueError(
+                "Monitoring has not been setup. Set create_if_not_exists or call ModelMonitorManager.setup"
+            )
+
+    def _get_and_validate_model_function_from_model_version(
+        self, function: str, model_version: model_version_impl.ModelVersion
+    ) -> model_manifest_schema.ModelFunctionInfo:
+        functions = model_version.show_functions()
+        for f in functions:
+            if f["target_method"] == function:
+                return f
+        existing_target_methods = {f["target_method"] for f in functions}
+        raise ValueError(
+            f"Function with name {function} does not exist in the given model version. "
+            f"Found: {existing_target_methods}."
+        )
+
+    def _validate_monitor_config_or_raise(
+        self,
+        table_config: model_monitor_config.ModelMonitorTableConfig,
+        model_monitor_config: model_monitor_config.ModelMonitorConfig,
+    ) -> None:
+        """Validate provided config for model monitor.
+
+        Args:
+            table_config: Config for model monitor tables.
+            model_monitor_config: Config for ModelMonitor.
+
+        Raises:
+            ValueError: If warehouse provided does not exist.
+        """
+
+        # Validate naming will not exceed 255 chars
+        _validate_name_constraints(model_monitor_config.model_version)
+
+        if len(table_config.prediction_columns) != len(table_config.label_columns):
+            raise ValueError("Prediction and Label column names must be of the same length.")
+        # output and ground cols are list to keep interface extensible.
+        # for prpr only one label and one output col will be supported
+        if len(table_config.prediction_columns) != 1 or len(table_config.label_columns) != 1:
+            raise ValueError("Multiple Output columns are not supported in monitoring")
+
+        # Validate warehouse exists.
+        warehouse_name_id = sql_identifier.SqlIdentifier(model_monitor_config.background_compute_warehouse_name)
+        self._model_monitor_client.validate_monitor_warehouse(warehouse_name_id, statement_params=self.statement_params)
+
+        # Validate refresh interval.
+        try:
+            num_units, time_units = model_monitor_config.refresh_interval.strip().split(" ")
+            int(num_units)  # try to cast
+            if time_units.lower() not in {"seconds", "minutes", "hours", "days"}:
+                raise ValueError(
+                    """Invalid time unit in refresh interval. Provide '<num> <seconds | minutes | hours | days>'.
+See https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table#required-parameters for more info."""
+                )
+        except Exception as e:  # TODO: Link to DT page.
+            raise ValueError(
+                f"""Failed to parse refresh interval with exception {e}.
+                Provide '<num> <seconds | minutes | hours | days>'.
+See https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table#required-parameters for more info."""
+            )
+
+    def add_monitor(
+        self,
+        name: str,
+        table_config: model_monitor_config.ModelMonitorTableConfig,
+        model_monitor_config: model_monitor_config.ModelMonitorConfig,
+        *,
+        add_dashboard_udtfs: bool = False,
+    ) -> model_monitor.ModelMonitor:
+        """Add a new Model Monitor.
+
+        Args:
+            name: Name of Model Monitor to create.
+            table_config: Configuration options for the source table used in ModelMonitor.
+            model_monitor_config: Configuration options of ModelMonitor.
+            add_dashboard_udtfs: Add UDTFs useful for creating a dashboard.
+
+        Returns:
+            The newly added ModelMonitor object.
+        """
+        # Validates configuration or raise.
+        self._validate_monitor_config_or_raise(table_config, model_monitor_config)
+        model_function = self._get_and_validate_model_function_from_model_version(
+            model_monitor_config.model_function_name, model_monitor_config.model_version
+        )
+        monitor_refresh_interval = model_monitor_interval.ModelMonitorRefreshInterval(
+            model_monitor_config.refresh_interval
+        )
+        name_id = sql_identifier.SqlIdentifier(name)
+        source_table_name_id = sql_identifier.SqlIdentifier(table_config.source_table)
+        prediction_columns = [
+            sql_identifier.SqlIdentifier(column_name) for column_name in table_config.prediction_columns
+        ]
+        label_columns = [sql_identifier.SqlIdentifier(column_name) for column_name in table_config.label_columns]
+        id_columns = [sql_identifier.SqlIdentifier(column_name) for column_name in table_config.id_columns]
+        ts_column = sql_identifier.SqlIdentifier(table_config.timestamp_column)
+
+        # Validate source table
+        self._model_monitor_client.validate_source_table(
+            source_table_name=source_table_name_id,
+            timestamp_column=ts_column,
+            prediction_columns=prediction_columns,
+            label_columns=label_columns,
+            id_columns=id_columns,
+            model_function=model_function,
+        )
+
+        task = self._fetch_task_from_model_version(model_version=model_monitor_config.model_version)
+        score_type = self._model_monitor_client.get_score_type(task, source_table_name_id, prediction_columns)
+
+        # Insert monitoring metadata for new model version.
+        self._model_monitor_client.create_monitor_on_model_version(
+            monitor_name=name_id,
+            source_table_name=source_table_name_id,
+            fully_qualified_model_name=model_monitor_config.model_version.fully_qualified_model_name,
+            version_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.version_name),
+            function_name=model_monitor_config.model_function_name,
+            timestamp_column=ts_column,
+            prediction_columns=prediction_columns,
+            label_columns=label_columns,
+            id_columns=id_columns,
+            task=task,
+            statement_params=self.statement_params,
+        )
+
+        # Create Dynamic tables for model monitor.
+        self._model_monitor_client.create_dynamic_tables_for_monitor(
+            model_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.model_name),
+            model_version_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.version_name),
+            task=task,
+            source_table_name=source_table_name_id,
+            refresh_interval=monitor_refresh_interval,
+            aggregation_window=model_monitor_config.aggregation_window,
+            warehouse_name=sql_identifier.SqlIdentifier(model_monitor_config.background_compute_warehouse_name),
+            timestamp_column=sql_identifier.SqlIdentifier(table_config.timestamp_column),
+            id_columns=id_columns,
+            prediction_columns=prediction_columns,
+            label_columns=label_columns,
+            score_type=score_type,
+        )
+
+        # Initialize baseline table.
+        self._model_monitor_client.initialize_baseline_table(
+            model_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.model_name),
+            version_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.version_name),
+            source_table_name=table_config.source_table,
+            columns_to_drop=[ts_column, *id_columns],
+            statement_params=self.statement_params,
+        )
+
+        # Add udtfs helpful for dashboard queries.
+        # TODO(apgupta) Make this true by default.
+        if add_dashboard_udtfs:
+            self._model_monitor_client.add_dashboard_udtfs(
+                name_id,
+                model_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.model_name),
+                model_version_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.version_name),
+                task=task,
+                score_type=score_type,
+                output_columns=prediction_columns,
+                ground_truth_columns=label_columns,
+            )
+
+        return model_monitor.ModelMonitor._ref(
+            model_monitor_client=self._model_monitor_client,
+            name=name_id,
+            fully_qualified_model_name=model_monitor_config.model_version.fully_qualified_model_name,
+            version_name=sql_identifier.SqlIdentifier(model_monitor_config.model_version.version_name),
+            function_name=sql_identifier.SqlIdentifier(model_monitor_config.model_function_name),
+            prediction_columns=prediction_columns,
+            label_columns=label_columns,
+        )
+
+    def get_monitor_by_model_version(
+        self, model_version: model_version_impl.ModelVersion
+    ) -> model_monitor.ModelMonitor:
+        fq_model_name = model_version.fully_qualified_model_name
+        version_name = sql_identifier.SqlIdentifier(model_version.version_name)
+        if self._model_monitor_client.validate_existence(fq_model_name, version_name, self.statement_params):
+            model_db, model_schema, model_name = sql_identifier.parse_fully_qualified_name(fq_model_name)
+            if model_db is None or model_schema is None:
+                raise ValueError("Failed to parse model name")
+
+            model_monitor_params: monitor_sql_client._ModelMonitorParams = (
+                self._model_monitor_client.get_model_monitor_by_model_version(
+                    model_db=model_db,
+                    model_schema=model_schema,
+                    model_name=model_name,
+                    version_name=version_name,
+                    statement_params=self.statement_params,
+                )
+            )
+            return model_monitor.ModelMonitor._ref(
+                model_monitor_client=self._model_monitor_client,
+                name=sql_identifier.SqlIdentifier(model_monitor_params["monitor_name"]),
+                fully_qualified_model_name=fq_model_name,
+                version_name=version_name,
+                function_name=sql_identifier.SqlIdentifier(model_monitor_params["function_name"]),
+                prediction_columns=model_monitor_params["prediction_columns"],
+                label_columns=model_monitor_params["label_columns"],
+            )
+
+        else:
+            raise ValueError(
+                f"ModelMonitor not found for model version {model_version.model_name} - {model_version.version_name}"
+            )
+
+    def get_monitor(self, name: str) -> model_monitor.ModelMonitor:
+        """Get a Model Monitor from the Registry
+
+        Args:
+            name: Name of Model Monitor to retrieve.
+
+        Raises:
+            ValueError: If model monitor is not found.
+
+        Returns:
+            The fetched ModelMonitor.
+        """
+        name_id = sql_identifier.SqlIdentifier(name)
+
+        if not self._model_monitor_client.validate_existence_by_name(
+            monitor_name=name_id,
+            statement_params=self.statement_params,
+        ):
+            raise ValueError(f"Unable to find model monitor '{name}'")
+        model_monitor_params: monitor_sql_client._ModelMonitorParams = (
+            self._model_monitor_client.get_model_monitor_by_name(name_id, statement_params=self.statement_params)
+        )
+
+        return model_monitor.ModelMonitor._ref(
+            model_monitor_client=self._model_monitor_client,
+            name=name_id,
+            fully_qualified_model_name=model_monitor_params["fully_qualified_model_name"],
+            version_name=sql_identifier.SqlIdentifier(model_monitor_params["version_name"]),
+            function_name=sql_identifier.SqlIdentifier(model_monitor_params["function_name"]),
+            prediction_columns=model_monitor_params["prediction_columns"],
+            label_columns=model_monitor_params["label_columns"],
+        )
+
+    def show_model_monitors(self) -> List[snowpark.Row]:
+        """Show all model monitors in the registry.
+
+        Returns:
+            List of snowpark.Row containing metadata for each model monitor.
+        """
+        return self._model_monitor_client.get_all_model_monitor_metadata()
+
+    def delete_monitor(self, name: str) -> None:
+        """Delete a Model Monitor from the Registry
+
+        Args:
+            name: Name of the Model Monitor to delete.
+        """
+        name_id = sql_identifier.SqlIdentifier(name)
+        monitor_params = self._model_monitor_client.get_model_monitor_by_name(name_id)
+        _, _, model = sql_identifier.parse_fully_qualified_name(monitor_params["fully_qualified_model_name"])
+        version = sql_identifier.SqlIdentifier(monitor_params["version_name"])
+        self._model_monitor_client.delete_monitor_metadata(name_id)
+        self._model_monitor_client.delete_baseline_table(model, version)
+        self._model_monitor_client.delete_dynamic_tables(model, version)

snowflake/ml/monitoring/_client/model_monitor_version.py

@@ -0,0 +1 @@
+SNOWFLAKE_ML_MONITORING_MIN_VERSION = "1.7.0"