snowflake-ml-python 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

snowflake/ml/modeling/xgboost/xgbrf_regressor.py

@@ -125,111 +125,171 @@ class XGBRFRegressor(BaseTransformer):
         can seriously hurt performance in gradient boosting. Set the batch_size as large as possible
         based on the available memory.
 
-    n_estimators: int
+    n_estimators: Optional[int]
             Number of trees in random forest to fit.
 
-        max_depth:  Optional[int]
+        max_depth:  typing.Optional[int]
+
             Maximum tree depth for base learners.
-        max_leaves :
+
+        max_leaves: typing.Optional[int]
+
             Maximum number of leaves; 0 indicates no limit.
-        max_bin :
+
+        max_bin: typing.Optional[int]
+
             If using histogram-based algorithm, maximum number of bins per feature
-        grow_policy :
-            Tree growing policy. 0: favor splitting at nodes closest to the node, i.e. grow
-            depth-wise. 1: favor splitting at nodes with highest loss change.
-        learning_rate: Optional[float]
+
+        grow_policy: typing.Optional[str]
+
+            Tree growing policy.
+
+            - depthwise: Favors splitting at nodes closest to the node,
+            - lossguide: Favors splitting at nodes with highest loss change.
+
+        learning_rate: typing.Optional[float]
+
             Boosting learning rate (xgb's "eta")
-        verbosity: Optional[int]
+
+        verbosity: typing.Optional[int]
+
             The degree of verbosity. Valid values are 0 (silent) - 3 (debug).
-        objective: typing.Union[str, typing.Callable[[numpy.ndarray, numpy.ndarray], typing.Tuple[numpy.ndarray, numpy.ndarray]], NoneType]
-            Specify the learning task and the corresponding learning objective or
-            a custom objective function to be used (see note below).
-        booster: Optional[str]
-            Specify which booster to use: gbtree, gblinear or dart.
-        tree_method: Optional[str]
+
+        objective: typing.Union[str, xgboost.sklearn._SklObjWProto, typing.Callable[[typing.Any, typing.Any], typing.Tuple[numpy.ndarray, numpy.ndarray]], NoneType]
+
+            Specify the learning task and the corresponding learning objective or a custom
+            objective function to be used.
+
+            For custom objective, see :doc:`/tutorials/custom_metric_obj` and
+            :ref:`custom-obj-metric` for more information, along with the end note for
+            function signatures.
+
+        booster: typing.Optional[str]
+
+            Specify which booster to use: ``gbtree``, ``gblinear`` or ``dart``.
+
+        tree_method: typing.Optional[str]
+
             Specify which tree method to use.  Default to auto.  If this parameter is set to
             default, XGBoost will choose the most conservative option available.  It's
             recommended to study this option from the parameters document :doc:`tree method
             </treemethod>`
-        n_jobs: Optional[int]
+
+        n_jobs: typing.Optional[int]
+
             Number of parallel threads used to run xgboost.  When used with other
             Scikit-Learn algorithms like grid search, you may choose which algorithm to
             parallelize and balance the threads.  Creating thread contention will
             significantly slow down both algorithms.
-        gamma: Optional[float]
-            (min_split_loss) Minimum loss reduction required to make a further partition on a
-            leaf node of the tree.
-        min_child_weight: Optional[float]
+
+        gamma: typing.Optional[float]
+
+            (min_split_loss) Minimum loss reduction required to make a further partition on
+            a leaf node of the tree.
+
+        min_child_weight: typing.Optional[float]
+
             Minimum sum of instance weight(hessian) needed in a child.
-        max_delta_step: Optional[float]
+
+        max_delta_step: typing.Optional[float]
+
             Maximum delta step we allow each tree's weight estimation to be.
-        subsample: Optional[float]
+
+        subsample: typing.Optional[float]
+
             Subsample ratio of the training instance.
-        sampling_method :
-            Sampling method. Used only by `gpu_hist` tree method.
-              - `uniform`: select random training instances uniformly.
-              - `gradient_based` select random training instances with higher probability when
-                the gradient and hessian are larger. (cf. CatBoost)
-        colsample_bytree: Optional[float]
+
+        sampling_method: typing.Optional[str]
+
+            Sampling method. Used only by the GPU version of ``hist`` tree method.
+
+            - ``uniform``: Select random training instances uniformly.
+            - ``gradient_based``: Select random training instances with higher probability
+                when the gradient and hessian are larger. (cf. CatBoost)
+
+        colsample_bytree: typing.Optional[float]
+
             Subsample ratio of columns when constructing each tree.
-        colsample_bylevel: Optional[float]
+
+        colsample_bylevel: typing.Optional[float]
+
             Subsample ratio of columns for each level.
-        colsample_bynode: Optional[float]
+
+        colsample_bynode: typing.Optional[float]
+
             Subsample ratio of columns for each split.
-        reg_alpha: Optional[float]
+
+        reg_alpha: typing.Optional[float]
+
             L1 regularization term on weights (xgb's alpha).
-        reg_lambda: Optional[float]
+
+        reg_lambda: typing.Optional[float]
+
             L2 regularization term on weights (xgb's lambda).
-        scale_pos_weight: Optional[float]
+
+        scale_pos_weight: typing.Optional[float]
             Balancing of positive and negative weights.
-        base_score: Optional[float]
+
+        base_score: typing.Optional[float]
+
             The initial prediction score of all instances, global bias.
-        random_state: Optional[Union[numpy.random.RandomState, int]]
+
+        random_state: typing.Union[numpy.random.mtrand.RandomState, numpy.random._generator.Generator, int, NoneType]
+
             Random number seed.
 
                Using gblinear booster with shotgun updater is nondeterministic as
                it uses Hogwild algorithm.
 
-        missing: float, default np.nan
-            Value in the data which needs to be present as a missing value.
-        num_parallel_tree: Optional[int]
+        missing: float
+
+            Value in the data which needs to be present as a missing value. Default to
+            :py:data:`numpy.nan`.
+
+        num_parallel_tree: typing.Optional[int]
+
             Used for boosting random forest.
-        monotone_constraints: Optional[Union[Dict[str, int], str]]
+
+        monotone_constraints: typing.Union[typing.Dict[str, int], str, NoneType]
+
             Constraint of variable monotonicity.  See :doc:`tutorial </tutorials/monotonic>`
             for more information.
-        interaction_constraints: Optional[Union[str, List[Tuple[str]]]]
+
+        interaction_constraints: typing.Union[str, typing.List[typing.Tuple[str]], NoneType]
+
             Constraints for interaction representing permitted interactions.  The
             constraints must be specified in the form of a nested list, e.g. ``[[0, 1], [2,
             3, 4]]``, where each inner list is a group of indices of features that are
             allowed to interact with each other.  See :doc:`tutorial
             </tutorials/feature_interaction_constraint>` for more information
-        importance_type: Optional[str]
+
+        importance_type: typing.Optional[str]
+
             The feature importance type for the feature_importances\_ property:
 
             * For tree model, it's either "gain", "weight", "cover", "total_gain" or
               "total_cover".
-            * For linear model, only "weight" is defined and it's the normalized coefficients
-              without bias.
+            * For linear model, only "weight" is defined and it's the normalized
+              coefficients without bias.
+
+        device: typing.Optional[str]
+
+            Device ordinal, available options are `cpu`, `cuda`, and `gpu`.
+
+        validate_parameters: typing.Optional[bool]
 
-        gpu_id: Optional[int]
-            Device ordinal.
-        validate_parameters: Optional[bool]
             Give warnings for unknown parameter.
-        predictor: Optional[str]
-            Force XGBoost to use specific predictor, available choices are [cpu_predictor,
-            gpu_predictor].
+
         enable_categorical: bool
 
-            Experimental support for categorical data.  When enabled, cudf/pandas.DataFrame
-            should be used to specify categorical data type.  Also, JSON/UBJSON
-            serialization format is required.
+            See the same parameter of :py:class:`DMatrix` for details.
 
-        feature_types: FeatureTypes
+        feature_types: typing.Optional[typing.Sequence[str]]
 
             Used for specifying feature types without constructing a dataframe. See
             :py:class:`DMatrix` for details.
 
-        max_cat_to_onehot: Optional[int]
+        max_cat_to_onehot: typing.Optional[int]
 
             A threshold for deciding whether XGBoost should use one-hot encoding based split
             for categorical data.  When number of categories is lesser than the threshold
@@ -238,36 +298,41 @@ class XGBRFRegressor(BaseTransformer):
             categorical feature support. See :doc:`Categorical Data
             </tutorials/categorical>` and :ref:`cat-param` for details.
 
-        max_cat_threshold: Optional[int]
+        max_cat_threshold: typing.Optional[int]
 
             Maximum number of categories considered for each split. Used only by
             partition-based splits for preventing over-fitting. Also, `enable_categorical`
             needs to be set to have categorical feature support. See :doc:`Categorical Data
             </tutorials/categorical>` and :ref:`cat-param` for details.
 
-        eval_metric: Optional[Union[str, List[str], Callable]]
+        multi_strategy: typing.Optional[str]
+
+            The strategy used for training multi-target models, including multi-target
+            regression and multi-class classification. See :doc:`/tutorials/multioutput` for
+            more information.
+
+            - ``one_output_per_tree``: One model for each target.
+            - ``multi_output_tree``:  Use multi-target trees.
+
+        eval_metric: typing.Union[str, typing.List[str], typing.Callable, NoneType]
 
             Metric used for monitoring the training result and early stopping.  It can be a
             string or list of strings as names of predefined metric in XGBoost (See
-            doc/parameter.rst), one of the metrics in :py:mod:`sklearn.metrics`, or any other
-            user defined metric that looks like `sklearn.metrics`.
+            doc/parameter.rst), one of the metrics in :py:mod:`sklearn.metrics`, or any
+            other user defined metric that looks like `sklearn.metrics`.
 
             If custom objective is also provided, then custom metric should implement the
             corresponding reverse link function.
 
             Unlike the `scoring` parameter commonly used in scikit-learn, when a callable
-            object is provided, it's assumed to be a cost function and by default XGBoost will
-            minimize the result during early stopping.
-
-            For advanced usage on Early stopping like directly choosing to maximize instead of
-            minimize, see :py:obj:`xgboost.callback.EarlyStopping`.
+            object is provided, it's assumed to be a cost function and by default XGBoost
+            will minimize the result during early stopping.
 
-            See :doc:`Custom Objective and Evaluation Metric </tutorials/custom_metric_obj>`
-            for more.
+            For advanced usage on Early stopping like directly choosing to maximize instead
+            of minimize, see :py:obj:`xgboost.callback.EarlyStopping`.
 
-                 This parameter replaces `eval_metric` in :py:meth:`fit` method.  The old one
-                 receives un-transformed prediction regardless of whether custom objective is
-                 being used.
+            See :doc:`/tutorials/custom_metric_obj` and :ref:`custom-obj-metric` for more
+            information.
 
                 from sklearn.datasets import load_diabetes
                 from sklearn.metrics import mean_absolute_error
@@ -278,24 +343,29 @@ class XGBRFRegressor(BaseTransformer):
                 )
                 reg.fit(X, y, eval_set=[(X, y)])
 
-        early_stopping_rounds: Optional[int]
+        early_stopping_rounds: typing.Optional[int]
 
-            Activates early stopping. Validation metric needs to improve at least once in
-            every **early_stopping_rounds** round(s) to continue training.  Requires at least
-            one item in **eval_set** in :py:meth:`fit`.
+            - Activates early stopping. Validation metric needs to improve at least once in
+              every **early_stopping_rounds** round(s) to continue training.  Requires at
+              least one item in **eval_set** in :py:meth:`fit`.
 
-            The method returns the model from the last iteration (not the best one).  If
-            there's more than one item in **eval_set**, the last entry will be used for early
-            stopping.  If there's more than one metric in **eval_metric**, the last metric
-            will be used for early stopping.
+            - If early stopping occurs, the model will have two additional attributes:
+              :py:attr:`best_score` and :py:attr:`best_iteration`. These are used by the
+              :py:meth:`predict` and :py:meth:`apply` methods to determine the optimal
+              number of trees during inference. If users want to access the full model
+              (including trees built after early stopping), they can specify the
+              `iteration_range` in these inference methods. In addition, other utilities
+              like model plotting can also use the entire model.
 
-            If early stopping occurs, the model will have three additional fields:
-            :py:attr:`best_score`, :py:attr:`best_iteration` and
-            :py:attr:`best_ntree_limit`.
+            - If you prefer to discard the trees after `best_iteration`, consider using the
+              callback function :py:class:`xgboost.callback.EarlyStopping`.
 
-                This parameter replaces `early_stopping_rounds` in :py:meth:`fit` method.
+            - If there's more than one item in **eval_set**, the last entry will be used for
+              early stopping.  If there's more than one metric in **eval_metric**, the last
+              metric will be used for early stopping.
+
+        callbacks: typing.Optional[typing.List[xgboost.callback.TrainingCallback]]
 
-        callbacks: Optional[List[TrainingCallback]]
             List of callback functions that are applied at end of each iteration.
             It is possible to use predefined callbacks by using
             :ref:`Callback API <callback_api>`.
@@ -307,9 +377,11 @@ class XGBRFRegressor(BaseTransformer):
                 for params in parameters_grid:
                     # be sure to (re)initialize the callbacks before each run
                     callbacks = [xgb.callback.LearningRateScheduler(custom_rates)]
-                    xgboost.train(params, Xy, callbacks=callbacks)
+                    reg = xgboost.XGBRegressor(**params, callbacks=callbacks)
+                    reg.fit(X, y)
+
+        kwargs: typing.Optional[typing.Any]
 
-        kwargs: dict, optional
             Keyword arguments for XGBoost Booster object.  Full documentation of parameters
             can be found :doc:`here </parameter>`.
             Attempting to set a parameter via the constructor args and \*\*kwargs
@@ -320,13 +392,16 @@ class XGBRFRegressor(BaseTransformer):
                 with scikit-learn.
 
                 A custom objective function can be provided for the ``objective``
-                parameter. In this case, it should have the signature
-                ``objective(y_true, y_pred) -> grad, hess``:
+                parameter. In this case, it should have the signature ``objective(y_true,
+                y_pred) -> [grad, hess]`` or ``objective(y_true, y_pred, *, sample_weight)
+                -> [grad, hess]``:
 
                 y_true: array_like of shape [n_samples]
                     The target values
                 y_pred: array_like of shape [n_samples]
                     The predicted values
+                sample_weight :
+                    Optional sample weights.
 
                 grad: array_like of shape [n_samples]
                     The value of the gradient for each sample point.

snowflake/ml/monitoring/_client/model_monitor_sql_client.py

@@ -1,6 +1,4 @@
-import typing
-from collections import Counter
-from typing import Any, Dict, List, Mapping, Optional, Set
+from typing import Any, Dict, List, Mapping, Optional
 
 from snowflake import snowpark
 from snowflake.ml._internal.utils import (
@@ -10,27 +8,12 @@ from snowflake.ml._internal.utils import (
     table_manager,
 )
 from snowflake.ml.model._client.sql import _base
-from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
 from snowflake.snowpark import session, types
 
-SNOWML_MONITORING_METADATA_TABLE_NAME = "_SYSTEM_MONITORING_METADATA"
-
 MODEL_JSON_COL_NAME = "model"
 MODEL_JSON_MODEL_NAME_FIELD = "model_name"
 MODEL_JSON_VERSION_NAME_FIELD = "version_name"
 
-MONITOR_NAME_COL_NAME = "MONITOR_NAME"
-SOURCE_TABLE_NAME_COL_NAME = "SOURCE_TABLE_NAME"
-FQ_MODEL_NAME_COL_NAME = "FULLY_QUALIFIED_MODEL_NAME"
-VERSION_NAME_COL_NAME = "MODEL_VERSION_NAME"
-FUNCTION_NAME_COL_NAME = "FUNCTION_NAME"
-TASK_COL_NAME = "TASK"
-MONITORING_ENABLED_COL_NAME = "IS_ENABLED"
-TIMESTAMP_COL_NAME_COL_NAME = "TIMESTAMP_COLUMN_NAME"
-PREDICTION_COL_NAMES_COL_NAME = "PREDICTION_COLUMN_NAMES"
-LABEL_COL_NAMES_COL_NAME = "LABEL_COLUMN_NAMES"
-ID_COL_NAMES_COL_NAME = "ID_COLUMN_NAMES"
-
 
 def _build_sql_list_from_columns(columns: List[sql_identifier.SqlIdentifier]) -> str:
     sql_list = ", ".join([f"'{column}'" for column in columns])
@@ -59,7 +42,7 @@ class ModelMonitorSQLClient:
     def _infer_qualified_schema(
         self, database_name: Optional[sql_identifier.SqlIdentifier], schema_name: Optional[sql_identifier.SqlIdentifier]
     ) -> str:
-        return f"{database_name or self._database_name}.{schema_name or self._schema_name}"
+        return f"""{database_name or self._database_name}.{schema_name or self._schema_name}"""
 
     def create_model_monitor(
         self,
@@ -91,17 +74,17 @@ class ModelMonitorSQLClient:
     ) -> None:
         baseline_sql = ""
         if baseline:
-            baseline_sql = f"BASELINE='{self._infer_qualified_schema(baseline_database, baseline_schema)}.{baseline}'"
+            baseline_sql = f"""BASELINE={self._infer_qualified_schema(baseline_database, baseline_schema)}.{baseline}"""
         query_result_checker.SqlResultValidator(
             self._sql_client._session,
             f"""
             CREATE MODEL MONITOR {self._infer_qualified_schema(monitor_database, monitor_schema)}.{monitor_name}
                 WITH
-                    MODEL='{self._infer_qualified_schema(model_database, model_schema)}.{model_name}'
+                    MODEL={self._infer_qualified_schema(model_database, model_schema)}.{model_name}
                     VERSION='{version_name}'
                     FUNCTION='{function_name}'
                     WAREHOUSE='{warehouse_name}'
-                    SOURCE='{self._infer_qualified_schema(source_database, source_schema)}.{source}'
+                    SOURCE={self._infer_qualified_schema(source_database, source_schema)}.{source}
                     ID_COLUMNS={_build_sql_list_from_columns(id_columns)}
                     PREDICTION_SCORE_COLUMNS={_build_sql_list_from_columns(prediction_score_columns)}
                     PREDICTION_CLASS_COLUMNS={_build_sql_list_from_columns(prediction_class_columns)}
@@ -146,19 +129,6 @@ class ModelMonitorSQLClient:
             .validate()
         )
 
-    def _validate_unique_columns(
-        self,
-        timestamp_column: sql_identifier.SqlIdentifier,
-        id_columns: List[sql_identifier.SqlIdentifier],
-        prediction_columns: List[sql_identifier.SqlIdentifier],
-        label_columns: List[sql_identifier.SqlIdentifier],
-    ) -> None:
-        all_columns = [*id_columns, *prediction_columns, *label_columns, timestamp_column]
-        num_all_columns = len(all_columns)
-        num_unique_columns = len(set(all_columns))
-        if num_all_columns != num_unique_columns:
-            raise ValueError("Column names must be unique across id, timestamp, prediction, and label columns.")
-
     def validate_existence_by_name(
         self,
         *,
@@ -244,125 +214,6 @@ 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.")
 
-    def _validate_timestamp_column_type(
-        self, table_schema: Mapping[str, types.DataType], timestamp_column: sql_identifier.SqlIdentifier
-    ) -> None:
-        """Ensures columns have the same type.
-
-        Args:
-            table_schema: Dictionary of column names and types in the source table.
-            timestamp_column: Name of the timestamp column.
-
-        Raises:
-            ValueError: If the timestamp column is not of type TimestampType.
-        """
-        if not isinstance(table_schema[timestamp_column], types.TimestampType):
-            raise ValueError(
-                f"Timestamp column: {timestamp_column} must be TimestampType. "
-                f"Found: {table_schema[timestamp_column]}"
-            )
-
-    def _validate_id_columns_types(
-        self, table_schema: Mapping[str, types.DataType], id_columns: List[sql_identifier.SqlIdentifier]
-    ) -> None:
-        """Ensures id columns have the correct type.
-
-        Args:
-            table_schema: Dictionary of column names and types in the source table.
-            id_columns: List of id column names.
-
-        Raises:
-            ValueError: If the id column is not of type StringType.
-        """
-        id_column_types = list({table_schema[column_name] for column_name in id_columns})
-        all_id_columns_string = all([isinstance(column_type, types.StringType) for column_type in id_column_types])
-        if not all_id_columns_string:
-            raise ValueError(f"Id columns must all be StringType. Found: {id_column_types}")
-
-    def _validate_prediction_columns_types(
-        self, table_schema: Mapping[str, types.DataType], prediction_columns: List[sql_identifier.SqlIdentifier]
-    ) -> None:
-        """Ensures prediction columns have the same type.
-
-        Args:
-            table_schema: Dictionary of column names and types in the source table.
-            prediction_columns: List of prediction column names.
-
-        Raises:
-            ValueError: If the prediction columns do not share the same type.
-        """
-
-        prediction_column_types = {table_schema[column_name] for column_name in prediction_columns}
-        if len(prediction_column_types) > 1:
-            raise ValueError(f"Prediction column types must be the same. Found: {prediction_column_types}")
-
-    def _validate_label_columns_types(
-        self,
-        table_schema: Mapping[str, types.DataType],
-        label_columns: List[sql_identifier.SqlIdentifier],
-    ) -> None:
-        """Ensures label columns have the same type, and the correct type for the score type.
-
-        Args:
-            table_schema: Dictionary of column names and types in the source table.
-            label_columns: List of label column names.
-
-        Raises:
-            ValueError: If the label columns do not share the same type.
-        """
-        label_column_types = {table_schema[column_name] for column_name in label_columns}
-        if len(label_column_types) > 1:
-            raise ValueError(f"Label column types must be the same. Found: {label_column_types}")
-
-    def _validate_column_types(
-        self,
-        *,
-        table_schema: Mapping[str, types.DataType],
-        timestamp_column: sql_identifier.SqlIdentifier,
-        id_columns: List[sql_identifier.SqlIdentifier],
-        prediction_columns: List[sql_identifier.SqlIdentifier],
-        label_columns: List[sql_identifier.SqlIdentifier],
-    ) -> None:
-        """Ensures columns have the expected type.
-
-        Args:
-            table_schema: Dictionary of column names and types in the source table.
-            timestamp_column: Name of the timestamp column.
-            id_columns: List of id column names.
-            prediction_columns: List of prediction column names.
-            label_columns: List of label column names.
-        """
-        self._validate_timestamp_column_type(table_schema, timestamp_column)
-        self._validate_id_columns_types(table_schema, id_columns)
-        self._validate_prediction_columns_types(table_schema, prediction_columns)
-        self._validate_label_columns_types(table_schema, label_columns)
-        # TODO(SNOW-1646693): Validate label makes sense with model task
-
-    def _validate_source_table_features_shape(
-        self,
-        table_schema: Mapping[str, types.DataType],
-        special_columns: Set[sql_identifier.SqlIdentifier],
-        model_function: model_manifest_schema.ModelFunctionInfo,
-    ) -> None:
-        table_schema_without_special_columns = {
-            k: v for k, v in table_schema.items() if sql_identifier.SqlIdentifier(k) not in special_columns
-        }
-        schema_column_types_to_count: typing.Counter[types.DataType] = Counter()
-        for column_type in table_schema_without_special_columns.values():
-            schema_column_types_to_count[column_type] += 1
-
-        inputs = model_function["signature"].inputs
-        function_input_types = [input.as_snowpark_type() for input in inputs]
-        function_input_types_to_count: typing.Counter[types.DataType] = Counter()
-        for function_input_type in function_input_types:
-            function_input_types_to_count[function_input_type] += 1
-
-        if function_input_types_to_count != schema_column_types_to_count:
-            raise ValueError(
-                "Model function input types do not match the source table input columns types. "
-                f"Model function expected: {inputs} but got {table_schema_without_special_columns}"
-            )
-
     def validate_source(
         self,
         *,
@@ -395,22 +246,6 @@ class ModelMonitorSQLClient:
             id_columns=id_columns,
         )
 
-    def delete_monitor_metadata(
-        self,
-        name: str,
-        statement_params: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        """Delete the row in the metadata table corresponding to the given monitor name.
-
-        Args:
-            name: Name of the model monitor whose metadata should be deleted.
-            statement_params: Optional set of statement_params to include with query.
-        """
-        self._sql_client._session.sql(
-            f"""DELETE FROM {self._database_name}.{self._schema_name}.{SNOWML_MONITORING_METADATA_TABLE_NAME}
-            WHERE {MONITOR_NAME_COL_NAME} = '{name}'""",
-        ).collect(statement_params=statement_params)
-
     def _alter_monitor(
         self,
         operation: str,

snowflake/ml/monitoring/_manager/model_monitor_manager.py

@@ -14,15 +14,6 @@ from snowflake.snowpark import session
 class ModelMonitorManager:
     """Class to manage internal operations for Model Monitor workflows."""
 
-    def _validate_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,
@@ -51,6 +42,15 @@ class ModelMonitorManager:
             schema_name=self._schema_name,
         )
 
+    def _validate_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 _validate_model_function_from_model_version(
         self, function: str, model_version: model_version_impl.ModelVersion
     ) -> None: