mlrun 1.10.0rc7__py3-none-any.whl → 1.10.0rc8__py3-none-any.whl

mlrun/serving/system_steps.py

@@ -0,0 +1,391 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import random
+from copy import copy, deepcopy
+from datetime import timedelta
+from typing import Any, Optional, Union
+
+import storey
+
+import mlrun
+import mlrun.artifacts
+import mlrun.common.schemas.model_monitoring as mm_schemas
+import mlrun.serving
+from mlrun.common.schemas import MonitoringData
+from mlrun.utils import logger
+
+
+class MonitoringPreProcessor(storey.MapClass):
+    """preprocess step, reconstructs the serving output event body to StreamProcessingEvent schema"""
+
+    def __init__(
+        self,
+        context,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.context = copy(context)
+
+    def reconstruct_request_resp_fields(
+        self, event, model: str, model_monitoring_data: dict
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        result_path = model_monitoring_data.get(MonitoringData.RESULT_PATH)
+        input_path = model_monitoring_data.get(MonitoringData.INPUT_PATH)
+
+        result = self._get_data_from_path(
+            result_path, event.body.get(model, event.body)
+        )
+        output_schema = model_monitoring_data.get(MonitoringData.OUTPUTS)
+        input_schema = model_monitoring_data.get(MonitoringData.INPUTS)
+        logger.debug("output schema retrieved", output_schema=output_schema)
+        if isinstance(result, dict):
+            if len(result) > 1:
+                # transpose by key the outputs:
+                outputs = self.transpose_by_key(result, output_schema)
+            elif len(result) == 1:
+                outputs = (
+                    result[output_schema[0]]
+                    if output_schema
+                    else list(result.values())[0]
+                )
+            else:
+                outputs = []
+            if not output_schema:
+                logger.warn(
+                    "Output schema was not provided using Project:log_model or by ModelRunnerStep:add_model order "
+                    "may not preserved"
+                )
+        else:
+            outputs = result
+
+        event_inputs = event._metadata.get("inputs", {})
+        event_inputs = self._get_data_from_path(input_path, event_inputs)
+        if isinstance(event_inputs, dict):
+            if len(event_inputs) > 1:
+                # transpose by key the inputs:
+                inputs = self.transpose_by_key(event_inputs, input_schema)
+            else:
+                inputs = (
+                    event_inputs[input_schema[0]]
+                    if input_schema
+                    else list(result.values())[0]
+                )
+        else:
+            inputs = event_inputs
+
+        if outputs and isinstance(outputs[0], list):
+            if output_schema and len(output_schema) != len(outputs[0]):
+                logger.info(
+                    "The number of outputs returned by the model does not match the number of outputs "
+                    "specified in the model endpoint.",
+                    model_endpoint=model,
+                    output_len=len(outputs[0]),
+                    schema_len=len(output_schema),
+                )
+        elif outputs:
+            if output_schema and len(output_schema) != 1:
+                logger.info(
+                    "The number of outputs returned by the model does not match the number of outputs "
+                    "specified in the model endpoint.",
+                    model_endpoint=model,
+                    output_len=len(outputs),
+                    schema_len=len(output_schema),
+                )
+        request = {"inputs": inputs, "id": getattr(event, "id", None)}
+        resp = {"outputs": outputs}
+
+        return request, resp
+
+    @staticmethod
+    def transpose_by_key(
+        data_to_transpose, schema: Optional[list[str]] = None
+    ) -> list[list[float]]:
+        values = (
+            list(data_to_transpose.values())
+            if not schema
+            else [data_to_transpose[key] for key in schema]
+        )
+        if values and not isinstance(values[0], list):
+            values = [values]
+        transposed = (
+            list(map(list, zip(*values)))
+            if all(isinstance(v, list) for v in values) and len(values) > 1
+            else values
+        )
+        return transposed
+
+    @staticmethod
+    def _get_data_from_path(
+        path: Union[str, list[str], None], data: dict
+    ) -> dict[str, Any]:
+        if isinstance(path, str):
+            output_data = data.get(path)
+        elif isinstance(path, list):
+            output_data = deepcopy(data)
+            for key in path:
+                output_data = output_data.get(key, {})
+        elif path is None:
+            output_data = data
+        else:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "Expected path be of type str or list of str or None"
+            )
+        if isinstance(output_data, (int, float)):
+            output_data = [output_data]
+        return output_data
+
+    def do(self, event):
+        monitoring_event_list = []
+        server: mlrun.serving.GraphServer = getattr(self.context, "server", None)
+        model_runner_name = event._metadata.get("model_runner_name", "")
+        step = server.graph.steps[model_runner_name] if server else {}
+        monitoring_data = step.monitoring_data
+        logger.debug(
+            "monitoring preprocessor started",
+            event=event,
+            model_endpoints=monitoring_data,
+            metadata=event._metadata,
+        )
+        if len(monitoring_data) > 1:
+            for model in event.body.keys():
+                if model in monitoring_data:
+                    request, resp = self.reconstruct_request_resp_fields(
+                        event, model, monitoring_data[model]
+                    )
+                    monitoring_event_list.append(
+                        {
+                            mm_schemas.StreamProcessingEvent.MODEL: model,
+                            mm_schemas.StreamProcessingEvent.MODEL_CLASS: monitoring_data[
+                                model
+                            ].get(mm_schemas.StreamProcessingEvent.MODEL_CLASS),
+                            mm_schemas.StreamProcessingEvent.MICROSEC: event._metadata.get(
+                                model, {}
+                            ).get(mm_schemas.StreamProcessingEvent.MICROSEC),
+                            mm_schemas.StreamProcessingEvent.WHEN: event._metadata.get(
+                                model, {}
+                            ).get(mm_schemas.StreamProcessingEvent.WHEN),
+                            mm_schemas.StreamProcessingEvent.ENDPOINT_ID: monitoring_data[
+                                model
+                            ].get(
+                                mlrun.common.schemas.MonitoringData.MODEL_ENDPOINT_UID
+                            ),
+                            mm_schemas.StreamProcessingEvent.LABELS: monitoring_data[
+                                model
+                            ].get(mlrun.common.schemas.MonitoringData.OUTPUTS),
+                            mm_schemas.StreamProcessingEvent.FUNCTION_URI: server.function_uri
+                            if server
+                            else None,
+                            mm_schemas.StreamProcessingEvent.REQUEST: request,
+                            mm_schemas.StreamProcessingEvent.RESPONSE: resp,
+                            mm_schemas.StreamProcessingEvent.ERROR: event.body[model][
+                                mm_schemas.StreamProcessingEvent.ERROR
+                            ]
+                            if mm_schemas.StreamProcessingEvent.ERROR
+                            in event.body[model]
+                            else None,
+                            mm_schemas.StreamProcessingEvent.METRICS: event.body[model][
+                                mm_schemas.StreamProcessingEvent.METRICS
+                            ]
+                            if mm_schemas.StreamProcessingEvent.METRICS
+                            in event.body[model]
+                            else None,
+                        }
+                    )
+        elif monitoring_data:
+            model = list(monitoring_data.keys())[0]
+            request, resp = self.reconstruct_request_resp_fields(
+                event, model, monitoring_data[model]
+            )
+            monitoring_event_list.append(
+                {
+                    mm_schemas.StreamProcessingEvent.MODEL: model,
+                    mm_schemas.StreamProcessingEvent.MODEL_CLASS: monitoring_data[
+                        model
+                    ].get(mm_schemas.StreamProcessingEvent.MODEL_CLASS),
+                    mm_schemas.StreamProcessingEvent.MICROSEC: event._metadata.get(
+                        mm_schemas.StreamProcessingEvent.MICROSEC
+                    ),
+                    mm_schemas.StreamProcessingEvent.WHEN: event._metadata.get(
+                        mm_schemas.StreamProcessingEvent.WHEN
+                    ),
+                    mm_schemas.StreamProcessingEvent.ENDPOINT_ID: monitoring_data[
+                        model
+                    ].get(mlrun.common.schemas.MonitoringData.MODEL_ENDPOINT_UID),
+                    mm_schemas.StreamProcessingEvent.LABELS: monitoring_data[model].get(
+                        mlrun.common.schemas.MonitoringData.OUTPUTS
+                    ),
+                    mm_schemas.StreamProcessingEvent.FUNCTION_URI: server.function_uri
+                    if server
+                    else None,
+                    mm_schemas.StreamProcessingEvent.REQUEST: request,
+                    mm_schemas.StreamProcessingEvent.RESPONSE: resp,
+                    mm_schemas.StreamProcessingEvent.ERROR: event.body[
+                        mm_schemas.StreamProcessingEvent.ERROR
+                    ]
+                    if mm_schemas.StreamProcessingEvent.ERROR in event.body
+                    else None,
+                    mm_schemas.StreamProcessingEvent.METRICS: event.body[
+                        mm_schemas.StreamProcessingEvent.METRICS
+                    ]
+                    if mm_schemas.StreamProcessingEvent.METRICS in event.body
+                    else None,
+                }
+            )
+        event.body = monitoring_event_list
+        return event
+
+
+class BackgroundTaskStatus(storey.MapClass):
+    """
+    background task status checker, prevent events from pushing to the model monitoring stream target if model endpoints
+    creation failed or in progress
+    """
+
+    def __init__(self, context, **kwargs):
+        self.context = copy(context)
+        self.server: mlrun.serving.GraphServer = getattr(self.context, "server", None)
+        self._background_task_check_timestamp = None
+        self._background_task_state = mlrun.common.schemas.BackgroundTaskState.running
+        super().__init__(**kwargs)
+
+    def do(self, event):
+        if (self.context and self.context.is_mock) or self.context is None:
+            return event
+        if self.server is None:
+            return None
+
+        if (
+            self._background_task_state
+            == mlrun.common.schemas.BackgroundTaskState.running
+            and (
+                self._background_task_check_timestamp is None
+                or mlrun.utils.now_date() - self._background_task_check_timestamp
+                >= timedelta(
+                    seconds=mlrun.mlconf.model_endpoint_monitoring.model_endpoint_creation_check_period
+                )
+            )
+        ):
+            background_task = mlrun.get_run_db().get_project_background_task(
+                self.server.project, self.server.model_endpoint_creation_task_name
+            )
+            self._background_task_check_timestamp = mlrun.utils.now_date()
+            self._log_background_task_state(background_task.status.state)
+            self._background_task_state = background_task.status.state
+            if (
+                background_task.status.state
+                == mlrun.common.schemas.BackgroundTaskState.succeeded
+            ):
+                return event
+            else:
+                return None
+        elif (
+            self._background_task_state
+            == mlrun.common.schemas.BackgroundTaskState.failed
+        ):
+            return None
+        return event
+
+    def _log_background_task_state(
+        self, background_task_state: mlrun.common.schemas.BackgroundTaskState
+    ):
+        logger.info(
+            "Checking model endpoint creation task status",
+            task_name=self.server.model_endpoint_creation_task_name,
+        )
+        if (
+            background_task_state
+            in mlrun.common.schemas.BackgroundTaskState.terminal_states()
+        ):
+            logger.info(
+                f"Model endpoint creation task completed with state {background_task_state}"
+            )
+        else:  # in progress
+            logger.info(
+                f"Model endpoint creation task is still in progress with the current state: "
+                f"{background_task_state}. Events will not be monitored for the next 15 seconds",
+                name=self.name,
+                background_task_check_timestamp=self._background_task_check_timestamp.isoformat(),
+            )
+
+
+class SamplingStep(storey.MapClass):
+    """sampling step, samples the serving outputs for the model monitoring as sampling_percentage defines"""
+
+    def __init__(
+        self,
+        sampling_percentage: Optional[float] = 100.0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.sampling_percentage = (
+            sampling_percentage if 0 < sampling_percentage <= 100 else 100
+        )
+
+    def do(self, event):
+        logger.debug(
+            "sampling step runs",
+            event=event,
+            sampling_percentage=self.sampling_percentage,
+        )
+        if self.sampling_percentage != 100:
+            request = event[mm_schemas.StreamProcessingEvent.REQUEST]
+            num_of_inputs = len(request["inputs"])
+            sampled_requests_indices = self._pick_random_requests(
+                num_of_inputs, self.sampling_percentage
+            )
+            if not sampled_requests_indices:
+                return None
+
+            event[mm_schemas.StreamProcessingEvent.REQUEST]["inputs"] = [
+                request["inputs"][i] for i in sampled_requests_indices
+            ]
+
+            if isinstance(
+                event[mm_schemas.StreamProcessingEvent.RESPONSE]["outputs"], list
+            ):
+                event[mm_schemas.StreamProcessingEvent.RESPONSE]["outputs"] = [
+                    event[mm_schemas.StreamProcessingEvent.RESPONSE]["outputs"][i]
+                    for i in sampled_requests_indices
+                ]
+        event[mm_schemas.EventFieldType.SAMPLING_PERCENTAGE] = self.sampling_percentage
+        event[mm_schemas.EventFieldType.EFFECTIVE_SAMPLE_COUNT] = len(
+            event.get(mm_schemas.StreamProcessingEvent.REQUEST, {}).get("inputs", [])
+        )
+        return event
+
+    @staticmethod
+    def _pick_random_requests(num_of_reqs: int, percentage: float) -> list[int]:
+        """
+        Randomly selects indices of requests to sample based on the given percentage
+
+        :param num_of_reqs: Number of requests to select from
+        :param percentage: Sample percentage for each request
+        :return: A list containing the indices of the selected requests
+        """
+
+        return [
+            req for req in range(num_of_reqs) if random.random() < (percentage / 100)
+        ]
+
+
+class MockStreamPusher(storey.MapClass):
+    def __init__(self, context, output_stream=None, **kwargs):
+        super().__init__(**kwargs)
+        self.output_stream = output_stream or context.stream.output_stream
+
+    def do(self, event):
+        self.output_stream.push(
+            [event], partition_key=mm_schemas.StreamProcessingEvent.ENDPOINT_ID
+        )

mlrun/serving/v2_serving.py

@@ -384,15 +384,15 @@ class V2ModelServer(StepToDict):
         return event
 
     def logged_results(self, request: dict, response: dict, op: str):
-        """hook for controlling which results are tracked by the model monitoring
+        """Hook for controlling which results are tracked by the model monitoring
 
-        this hook allows controlling which input/output data is logged by the model monitoring
-        allow filtering out columns or adding custom values, can also be used to monitor derived metrics
-        for example in image classification calculate and track the RGB values vs the image bitmap
+        This hook allows controlling which input/output data is logged by the model monitoring.
+        It allows filtering out columns or adding custom values, and can also be used to monitor derived metrics,
+        for example in image classification to calculate and track the RGB values vs the image bitmap.
 
-        the request["inputs"] holds a list of input values/arrays, the response["outputs"] holds a list of
-        corresponding output values/arrays (the schema of the input/output fields is stored in the model object),
-        this method should return lists of alternative inputs and outputs which will be monitored
+        The request ["inputs"] holds a list of input values/arrays, the response ["outputs"] holds a list of
+        corresponding output values/arrays (the schema of the input/output fields is stored in the model object).
+        This method should return lists of alternative inputs and outputs which will be monitored.
 
         :param request:   predict/explain request, see model serving docs for details
         :param response:  result from the model predict/explain (after postprocess())
@@ -422,6 +422,7 @@ class V2ModelServer(StepToDict):
 
     def predict(self, request: dict) -> list:
         """model prediction operation
+
         :return: list with the model prediction results (can be multi-port) or list of lists for multiple predictions
         """
         raise NotImplementedError()
@@ -436,7 +437,7 @@ class V2ModelServer(StepToDict):
         where the internal list order is according to the ArtifactModel inputs.
 
         :param request: event
-        :return: evnet body converting the inputs to be list of lists
+        :return: event body converting the inputs to be list of lists
         """
         if self.model_spec and self.model_spec.inputs:
             input_order = [feature.name for feature in self.model_spec.inputs]

mlrun/utils/helpers.py

@@ -2121,6 +2121,23 @@ def join_urls(base_url: Optional[str], path: Optional[str]) -> str:
     return f"{base_url.rstrip('/')}/{path.lstrip('/')}" if path else base_url
 
 
+def warn_on_deprecated_image(image: Optional[str]):
+    """
+    Warn if the provided image is the deprecated 'mlrun/ml-base' image.
+    This image is deprecated as of 1.10.0 and will be removed in 1.12.0.
+    """
+    deprecated_images = ["mlrun/ml-base"]
+    if image and any(
+        image in deprecated_image for deprecated_image in deprecated_images
+    ):
+        warnings.warn(
+            "'mlrun/ml-base' image is deprecated in 1.10.0 and will be replaced by 'mlrun/mlrun'. "
+            "This behavior will be removed in 1.12.0 ",
+            # TODO: Remove this in 1.12.0
+            FutureWarning,
+        )
+
+
 class Workflow:
     @staticmethod
     def get_workflow_steps(
@@ -2290,6 +2307,7 @@ class Workflow:
         workflow_id: str,
     ) -> typing.Optional[mlrun_pipelines.models.PipelineManifest]:
         kfp_client = mlrun_pipelines.utils.get_client(
+            logger=logger,
             url=mlrun.mlconf.kfp_url,
             namespace=mlrun.mlconf.namespace,
         )

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "7e46ae9ef39327d23bfacc0910fef7b83e23e75d",
-  "version": "1.10.0-rc7"
+  "git_commit": "fede26558b2c8db736315ad1f48e15e3ce2f387d",
+  "version": "1.10.0-rc8"
 }

{mlrun-1.10.0rc7.dist-info → mlrun-1.10.0rc8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlrun
-Version: 1.10.0rc7
+Version: 1.10.0rc8
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -52,7 +52,7 @@ Requires-Dist: setuptools>=75.2
 Requires-Dist: deprecated~=1.2
 Requires-Dist: jinja2>=3.1.6,~=3.1
 Requires-Dist: orjson<4,>=3.9.15
-Requires-Dist: mlrun-pipelines-kfp-common~=0.5.5
+Requires-Dist: mlrun-pipelines-kfp-common~=0.5.6
 Requires-Dist: mlrun-pipelines-kfp-v1-8~=0.5.4
 Requires-Dist: docstring_parser~=0.16
 Requires-Dist: aiosmtplib~=3.0
@@ -250,7 +250,7 @@ Dynamic: summary
 [![Documentation](https://readthedocs.org/projects/mlrun/badge/?version=latest)](https://mlrun.readthedocs.io/en/latest/?badge=latest)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/w/mlrun/mlrun)
-![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/mlrun/mlrun?sort=semver)
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/mlrun/mlrun?sort=semver)](https://github.com/mlrun/mlrun/releases)
 [![Join MLOps Live](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://mlopslive.slack.com)
 
 <div>
@@ -298,9 +298,9 @@ Removing inappropriate data at an early stage saves resources that would otherwi
 [Vector databases](https://docs.mlrun.org/en/stable/genai/data-mgmt/vector-databases.html)
 [Guardrails for data management](https://docs.mlrun.org/en/stable/genai/data-mgmt/guardrails-data.html)
 **Demo:**
-[Call center demo](https://github.com/mlrun/demo-call-center>`
+[Call center demo](https://github.com/mlrun/demo-call-center)
 **Video:**
-[Call center](https://youtu.be/YycMbxRgLBA>`
+[Call center](https://youtu.be/YycMbxRgLBA)
 
 ### Development
 Use MLRun to build an automated ML pipeline to: collect data, 
@@ -321,13 +321,13 @@ inferring results using one or more models, and driving actions.
 
 
 **Docs:**
-[Serving gen AI models](https://docs.mlrun.org/en/stable/genai/deployment/genai_serving.html), GPU utilization](https://docs.mlrun.org/en/stable/genai/deployment/gpu_utilization.html), [Gen AI realtime serving graph](https://docs.mlrun.org/en/stable/genai/deployment/genai_serving_graph.html)
+[Serving gen AI models](https://docs.mlrun.org/en/stable/genai/deployment/genai_serving.html), [GPU utilization](https://docs.mlrun.org/en/stable/genai/deployment/gpu_utilization.html), [Gen AI realtime serving graph](https://docs.mlrun.org/en/stable/genai/deployment/genai_serving_graph.html)
 **Tutorial:**
 [Deploy LLM using MLRun](https://docs.mlrun.org/en/stable/tutorials/genai_01_basic_tutorial.html)
 **Demos:**
-[Call center demo](https://github.com/mlrun/demo-call-center), [Build & deploy custom(fine-tuned)]LLM models and applications <https://github.com/mlrun/demo-llm-tuning/blob/main), [Interactive bot demo using LLMs]<https://github.com/mlrun/demo-llm-bot/blob/main)
+[Call center demo](https://github.com/mlrun/demo-call-center), [Build & deploy custom(fine-tuned)LLM models and applications](https://github.com/mlrun/demo-llm-tuning/blob/main), [Interactive bot demo using LLMs](https://github.com/mlrun/demo-llm-bot/blob/main)
 **Video:**
-[Call center]<https://youtu.be/YycMbxRgLBA)
+[Call center](https://youtu.be/YycMbxRgLBA)
 
 
 ### Live Ops