mlrun 1.7.0rc43__py3-none-any.whl → 1.7.0rc55__py3-none-any.whl

mlrun/model_monitoring/applications/base.py

@@ -13,19 +13,14 @@
 # limitations under the License.
 
 from abc import ABC, abstractmethod
-from typing import Any, Union, cast
+from typing import Any, Union
 
-import numpy as np
-import pandas as pd
-from deprecated import deprecated
-
-import mlrun
 import mlrun.model_monitoring.applications.context as mm_context
 import mlrun.model_monitoring.applications.results as mm_results
 from mlrun.serving.utils import MonitoringApplicationToDict
 
 
-class ModelMonitoringApplicationBaseV2(MonitoringApplicationToDict, ABC):
+class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
     """
     A base class for a model monitoring application.
     Inherit from this class to create a custom model monitoring application.
@@ -111,178 +106,3 @@ class ModelMonitoringApplicationBaseV2(MonitoringApplicationToDict, ABC):
                                         each metric name is the key and the metric value is the corresponding value).
         """
         raise NotImplementedError
-
-
-# TODO: Remove in 1.9.0
-@deprecated(
-    version="1.7.0",
-    reason="The `ModelMonitoringApplicationBase` class is deprecated from "
-    "version 1.7.0 and will be removed in version 1.9.0. "
-    "Use `ModelMonitoringApplicationBaseV2` as your application's base class.",
-)
-class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
-    """
-    A base class for a model monitoring application.
-    Inherit from this class to create a custom model monitoring application.
-
-    example for very simple custom application::
-
-        class MyApp(ApplicationBase):
-            def do_tracking(
-                self,
-                sample_df_stats: mlrun.common.model_monitoring.helpers.FeatureStats,
-                feature_stats: mlrun.common.model_monitoring.helpers.FeatureStats,
-                start_infer_time: pd.Timestamp,
-                end_infer_time: pd.Timestamp,
-                schedule_time: pd.Timestamp,
-                latest_request: pd.Timestamp,
-                endpoint_id: str,
-                output_stream_uri: str,
-            ) -> ModelMonitoringApplicationResult:
-                self.context.log_artifact(
-                    TableArtifact(
-                        "sample_df_stats", df=self.dict_to_histogram(sample_df_stats)
-                    )
-                )
-                return ModelMonitoringApplicationResult(
-                    name="data_drift_test",
-                    value=0.5,
-                    kind=mm_constant.ResultKindApp.data_drift,
-                    status=mm_constant.ResultStatusApp.detected,
-                )
-
-
-    """
-
-    kind = "monitoring_application"
-
-    def do(
-        self, monitoring_context: mm_context.MonitoringApplicationContext
-    ) -> tuple[
-        list[mm_results.ModelMonitoringApplicationResult],
-        mm_context.MonitoringApplicationContext,
-    ]:
-        """
-        Process the monitoring event and return application results.
-
-        :param monitoring_context:   (MonitoringApplicationContext) The monitoring context to process.
-        :returns:                    A tuple of:
-                                        [0] = list of application results that can be either from type
-                                        `ModelMonitoringApplicationResult` or from type
-                                        `ModelMonitoringApplicationResult`.
-                                        [1] = the original application event, wrapped in `MonitoringApplicationContext`
-                                         object
-        """
-        resolved_event = self._resolve_event(monitoring_context)
-        if not (
-            hasattr(self, "context") and isinstance(self.context, mlrun.MLClientCtx)
-        ):
-            self._lazy_init(monitoring_context)
-        results = self.do_tracking(*resolved_event)
-        results = results if isinstance(results, list) else [results]
-        return results, monitoring_context
-
-    def _lazy_init(self, monitoring_context: mm_context.MonitoringApplicationContext):
-        self.context = cast(mlrun.MLClientCtx, monitoring_context)
-
-    @abstractmethod
-    def do_tracking(
-        self,
-        application_name: str,
-        sample_df_stats: pd.DataFrame,
-        feature_stats: pd.DataFrame,
-        sample_df: pd.DataFrame,
-        start_infer_time: pd.Timestamp,
-        end_infer_time: pd.Timestamp,
-        latest_request: pd.Timestamp,
-        endpoint_id: str,
-        output_stream_uri: str,
-    ) -> Union[
-        mm_results.ModelMonitoringApplicationResult,
-        list[mm_results.ModelMonitoringApplicationResult],
-    ]:
-        """
-        Implement this method with your custom monitoring logic.
-
-        :param application_name:        (str) the app name
-        :param sample_df_stats:         (pd.DataFrame) The new sample distribution.
-        :param feature_stats:           (pd.DataFrame) The train sample distribution.
-        :param sample_df:               (pd.DataFrame) The new sample DataFrame.
-        :param start_infer_time:        (pd.Timestamp) Start time of the monitoring schedule.
-        :param end_infer_time:          (pd.Timestamp) End time of the monitoring schedule.
-        :param latest_request:          (pd.Timestamp) Timestamp of the latest request on this endpoint_id.
-        :param endpoint_id:             (str) ID of the monitored model endpoint
-        :param output_stream_uri:       (str) URI of the output stream for results
-
-        :returns:                       (ModelMonitoringApplicationResult) or
-                                        (list[ModelMonitoringApplicationResult]) of the application results.
-        """
-        raise NotImplementedError
-
-    @classmethod
-    def _resolve_event(
-        cls,
-        monitoring_context: mm_context.MonitoringApplicationContext,
-    ) -> tuple[
-        str,
-        pd.DataFrame,
-        pd.DataFrame,
-        pd.DataFrame,
-        pd.Timestamp,
-        pd.Timestamp,
-        pd.Timestamp,
-        str,
-        str,
-    ]:
-        """
-        Converting the event into a single tuple that will be used for passing the event arguments to the running
-        application
-
-        :param monitoring_context: (MonitoringApplicationContext) The monitoring context to process.
-
-        :return: A tuple of:
-                     [0] = (str) application name
-                     [1] = (pd.DataFrame) current input statistics
-                     [2] = (pd.DataFrame) train statistics
-                     [3] = (pd.DataFrame) current input data
-                     [4] = (pd.Timestamp) start time of the monitoring schedule
-                     [5] = (pd.Timestamp) end time of the monitoring schedule
-                     [6] = (pd.Timestamp) timestamp of the latest request
-                     [7] = (str) endpoint id
-                     [8] = (str) output stream uri
-        """
-        return (
-            monitoring_context.application_name,
-            cls.dict_to_histogram(monitoring_context.sample_df_stats),
-            cls.dict_to_histogram(monitoring_context.feature_stats),
-            monitoring_context.sample_df,
-            monitoring_context.start_infer_time,
-            monitoring_context.end_infer_time,
-            monitoring_context.latest_request,
-            monitoring_context.endpoint_id,
-            monitoring_context.output_stream_uri,
-        )
-
-    @staticmethod
-    def dict_to_histogram(
-        histogram_dict: mlrun.common.model_monitoring.helpers.FeatureStats,
-    ) -> pd.DataFrame:
-        """
-        Convert histogram dictionary to pandas DataFrame with feature histograms as columns
-
-        :param histogram_dict: Histogram dictionary
-
-        :returns: Histogram dataframe
-        """
-
-        # Create a dictionary with feature histograms as values
-        histograms = {}
-        for feature, stats in histogram_dict.items():
-            if "hist" in stats:
-                # Normalize to probability distribution of each feature
-                histograms[feature] = np.array(stats["hist"][0]) / stats["count"]
-
-        # Convert the dictionary to pandas DataFrame
-        histograms = pd.DataFrame(histograms)
-
-        return histograms

mlrun/model_monitoring/applications/context.py

@@ -98,9 +98,6 @@ class MonitoringApplicationContext:
         self.end_infer_time = pd.Timestamp(
             cast(str, event.get(mm_constants.ApplicationEvent.END_INFER_TIME))
         )
-        self.latest_request = pd.Timestamp(
-            cast(str, event.get(mm_constants.ApplicationEvent.LAST_REQUEST))
-        )
         self.endpoint_id = cast(
             str, event.get(mm_constants.ApplicationEvent.ENDPOINT_ID)
         )
@@ -108,12 +105,8 @@ class MonitoringApplicationContext:
             str, event.get(mm_constants.ApplicationEvent.OUTPUT_STREAM_URI)
         )
 
-        self._feature_stats: Optional[FeatureStats] = json.loads(
-            event.get(mm_constants.ApplicationEvent.FEATURE_STATS, "{}")
-        )
-        self._sample_df_stats: Optional[FeatureStats] = json.loads(
-            event.get(mm_constants.ApplicationEvent.CURRENT_STATS, "{}")
-        )
+        self._feature_stats: Optional[FeatureStats] = None
+        self._sample_df_stats: Optional[FeatureStats] = None
 
         # Default labels for the artifacts
         self._default_labels = self._get_default_labels()

mlrun/model_monitoring/applications/evidently_base.py

@@ -18,7 +18,6 @@ from abc import ABC
 
 import pandas as pd
 import semver
-from deprecated import deprecated
 
 import mlrun.model_monitoring.applications.base as mm_base
 import mlrun.model_monitoring.applications.context as mm_context
@@ -64,13 +63,6 @@ if _HAS_EVIDENTLY:
     from evidently.utils.dashboard import TemplateParams, file_html_template
 
 
-# TODO: Remove in 1.9.0
-@deprecated(
-    version="1.7.0",
-    reason="The `EvidentlyModelMonitoringApplicationBase` class is deprecated from "
-    "version 1.7.0 and will be removed in version 1.9.0. "
-    "Use `EvidentlyModelMonitoringApplicationBaseV2` as your application's base class.",
-)
 class EvidentlyModelMonitoringApplicationBase(
     mm_base.ModelMonitoringApplicationBase, ABC
 ):
@@ -85,72 +77,6 @@ class EvidentlyModelMonitoringApplicationBase(
         :param evidently_workspace_path:    (str) The path to the Evidently workspace.
         :param evidently_project_id:        (str) The ID of the Evidently project.
 
-        """
-        if not _HAS_EVIDENTLY:
-            raise ModuleNotFoundError("Evidently is not installed - the app cannot run")
-        self.evidently_workspace = Workspace.create(evidently_workspace_path)
-        self.evidently_project_id = evidently_project_id
-        self.evidently_project = self.evidently_workspace.get_project(
-            evidently_project_id
-        )
-
-    def log_evidently_object(
-        self, evidently_object: "Display", artifact_name: str
-    ) -> None:
-        """
-         Logs an Evidently report or suite as an artifact.
-
-        :param evidently_object:    (Display) The Evidently display to log, e.g. a report or a test suite object.
-        :param artifact_name:       (str) The name for the logged artifact.
-        """
-        evidently_object_html = evidently_object.get_html()
-        self.context.log_artifact(
-            artifact_name, body=evidently_object_html.encode("utf-8"), format="html"
-        )
-
-    def log_project_dashboard(
-        self,
-        timestamp_start: pd.Timestamp,
-        timestamp_end: pd.Timestamp,
-        artifact_name: str = "dashboard",
-    ):
-        """
-        Logs an Evidently project dashboard.
-
-        :param timestamp_start: (pd.Timestamp) The start timestamp for the dashboard data.
-        :param timestamp_end:   (pd.Timestamp) The end timestamp for the dashboard data.
-        :param artifact_name:   (str) The name for the logged artifact.
-        """
-
-        dashboard_info = self.evidently_project.build_dashboard_info(
-            timestamp_start, timestamp_end
-        )
-        template_params = TemplateParams(
-            dashboard_id="pd_" + str(uuid.uuid4()).replace("-", ""),
-            dashboard_info=dashboard_info,
-            additional_graphs={},
-        )
-
-        dashboard_html = file_html_template(params=template_params)
-        self.context.log_artifact(
-            artifact_name, body=dashboard_html.encode("utf-8"), format="html"
-        )
-
-
-class EvidentlyModelMonitoringApplicationBaseV2(
-    mm_base.ModelMonitoringApplicationBaseV2, ABC
-):
-    def __init__(
-        self, evidently_workspace_path: str, evidently_project_id: "STR_UUID"
-    ) -> None:
-        """
-        A class for integrating Evidently for mlrun model monitoring within a monitoring application.
-        Note: evidently is not installed by default in the mlrun/mlrun image.
-        It must be installed separately to use this class.
-
-        :param evidently_workspace_path:    (str) The path to the Evidently workspace.
-        :param evidently_project_id:        (str) The ID of the Evidently project.
-
         """
 
         # TODO : more then one project (mep -> project)

mlrun/model_monitoring/applications/histogram_data_drift.py

@@ -31,7 +31,7 @@ from mlrun.common.schemas.model_monitoring.constants import (
     ResultStatusApp,
 )
 from mlrun.model_monitoring.applications import (
-    ModelMonitoringApplicationBaseV2,
+    ModelMonitoringApplicationBase,
 )
 from mlrun.model_monitoring.metrics.histogram_distance import (
     HellingerDistance,
@@ -87,7 +87,7 @@ class DataDriftClassifier:
         return ResultStatusApp.no_detection
 
 
-class HistogramDataDriftApplication(ModelMonitoringApplicationBaseV2):
+class HistogramDataDriftApplication(ModelMonitoringApplicationBase):
     """
     MLRun's default data drift application for model monitoring.
 

mlrun/model_monitoring/applications/results.py

@@ -29,8 +29,8 @@ class _ModelMonitoringApplicationDataRes(ABC):
     def __post_init__(self):
         pat = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
         if not re.fullmatch(pat, self.name):
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                "Attribute name must be of the format [a-zA-Z_][a-zA-Z0-9_]*"
+            raise mlrun.errors.MLRunValueError(
+                "Attribute name must comply with the regex `[a-zA-Z_][a-zA-Z0-9_]*`"
             )
 
     @abstractmethod
@@ -45,7 +45,7 @@ class ModelMonitoringApplicationResult(_ModelMonitoringApplicationDataRes):
 
     :param name:           (str) Name of the application result. This name must be
                             unique for each metric in a single application
-                            (name must be of the format [a-zA-Z_][a-zA-Z0-9_]*).
+                            (name must be of the format :code:`[a-zA-Z_][a-zA-Z0-9_]*`).
     :param value:          (float) Value of the application result.
     :param kind:           (ResultKindApp) Kind of application result.
     :param status:         (ResultStatusApp) Status of the application result.
@@ -80,7 +80,7 @@ class ModelMonitoringApplicationMetric(_ModelMonitoringApplicationDataRes):
 
     :param name:           (str) Name of the application metric. This name must be
                             unique for each metric in a single application
-                            (name must be of the format [a-zA-Z_][a-zA-Z0-9_]*).
+                            (name must be of the format :code:`[a-zA-Z_][a-zA-Z0-9_]*`).
     :param value:          (float) Value of the application metric.
     """