oracle-ads 2.12.8__py3-none-any.whl → 2.12.10__py3-none-any.whl

ads/opctl/operator/lowcode/forecast/whatifserve/deployment_manager.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python
+import json
+# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import os
+import pickle
+import shutil
+import sys
+import tempfile
+import oci
+
+import pandas as pd
+import cloudpickle
+
+from ads.opctl import logger
+from ads.common.model_export_util import prepare_generic_model
+from ads.opctl.operator.lowcode.common.utils import write_data, write_simple_json
+from ads.opctl.operator.lowcode.common.utils import default_signer
+from ..model.forecast_datasets import AdditionalData
+from ..operator_config import ForecastOperatorSpec
+
+from oci.data_science import DataScienceClient, DataScienceClientCompositeOperations
+
+from oci.data_science.models import ModelConfigurationDetails, InstanceConfiguration, \
+    FixedSizeScalingPolicy, CategoryLogDetails, LogDetails, \
+    SingleModelDeploymentConfigurationDetails, CreateModelDeploymentDetails
+from ads.common.object_storage_details import ObjectStorageDetails
+
+
+class ModelDeploymentManager:
+    def __init__(self, spec: ForecastOperatorSpec, additional_data: AdditionalData, previous_model_version=None):
+        self.spec = spec
+        self.model_name = spec.model
+        self.horizon = spec.horizon
+        self.additional_data = additional_data.get_dict_by_series()
+        self.model_obj = {}
+        self.display_name = spec.what_if_analysis.model_display_name
+        self.project_id = spec.what_if_analysis.project_id if spec.what_if_analysis.project_id \
+            else os.environ.get('PROJECT_OCID')
+        self.compartment_id = spec.what_if_analysis.compartment_id if spec.what_if_analysis.compartment_id \
+            else os.environ.get('NB_SESSION_COMPARTMENT_OCID')
+        if self.project_id is None or self.compartment_id is None:
+            raise ValueError("Either project_id or compartment_id cannot be None.")
+        self.path_to_artifact = f"{self.spec.output_directory.url}/artifacts/"
+        self.pickle_file_path = f"{self.spec.output_directory.url}/model.pkl"
+        self.model_version = previous_model_version + 1 if previous_model_version else 1
+        self.catalog_id = None
+        self.test_mode = os.environ.get("TEST_MODE", False)
+        self.deployment_info = {}
+
+    def _sanity_test(self):
+        """
+        Function perform sanity test for saved artifact
+        """
+        org_sys_path = sys.path[:]
+        try:
+            sys.path.insert(0, f"{self.path_to_artifact}")
+            from score import load_model, predict
+            _ = load_model()
+
+            # Write additional data to tmp file and perform sanity check
+            with tempfile.NamedTemporaryFile(suffix='.csv') as temp_file:
+                one_series = next(iter(self.additional_data))
+                sample_prediction_data = self.additional_data[one_series].tail(self.horizon)
+                sample_prediction_data[self.spec.target_category_columns[0]] = one_series
+                date_col_name = self.spec.datetime_column.name
+                date_col_format = self.spec.datetime_column.format
+                sample_prediction_data[date_col_name] = sample_prediction_data[date_col_name].dt.strftime(
+                    date_col_format)
+                sample_prediction_data.to_csv(temp_file.name, index=False)
+                input_data = {"additional_data": {"url": temp_file.name}}
+                prediction_test = predict(input_data, _)
+                logger.info(f"prediction test completed with result :{prediction_test}")
+        except Exception as e:
+            logger.error(f"An error occurred during the sanity test: {e}")
+            raise
+        finally:
+            sys.path = org_sys_path
+
+    def _copy_score_file(self):
+        """
+        Copies the score.py to the artifact_path.
+        """
+        try:
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            score_file = os.path.join(current_dir, "score.py")
+            destination_file = os.path.join(self.path_to_artifact, os.path.basename(score_file))
+            shutil.copy2(score_file, destination_file)
+            logger.info(f"score.py copied successfully to {self.path_to_artifact}")
+        except Exception as e:
+            logger.warn(f"Error copying file: {e}")
+            raise e
+
+    def save_to_catalog(self):
+        """Save the model to a model catalog"""
+        with open(self.pickle_file_path, 'rb') as file:
+            self.model_obj = pickle.load(file)
+
+        if not os.path.exists(self.path_to_artifact):
+            os.mkdir(self.path_to_artifact)
+
+        artifact_dict = {"spec": self.spec.to_dict(), "models": self.model_obj}
+        with open(f"{self.path_to_artifact}/models.pickle", "wb") as f:
+            cloudpickle.dump(artifact_dict, f)
+        artifact = prepare_generic_model(
+            self.path_to_artifact,
+            function_artifacts=False,
+            force_overwrite=True,
+            data_science_env=True)
+
+        self._copy_score_file()
+        self._sanity_test()
+
+        if isinstance(self.model_obj, dict):
+            series = self.model_obj.keys()
+        else:
+            series = self.additional_data.keys()
+        description = f"The object contains {len(series)} {self.model_name} models"
+
+        if not self.test_mode:
+            catalog_entry = artifact.save(
+                display_name=self.display_name,
+                compartment_id=self.compartment_id,
+                project_id=self.project_id,
+                description=description)
+            self.catalog_id = catalog_entry.id
+
+        logger.info(f"Saved {self.model_name} version-v{self.model_version} to model catalog"
+                    f" with model ocid : {self.catalog_id}")
+
+        self.deployment_info = {"model_ocid": self.catalog_id, "series": list(series)}
+
+    def create_deployment(self):
+        """Create a model deployment serving"""
+
+        # create new model deployment
+        initial_shape = self.spec.what_if_analysis.model_deployment.initial_shape
+        name = self.spec.what_if_analysis.model_deployment.display_name
+        description = self.spec.what_if_analysis.model_deployment.description
+        auto_scaling_config = self.spec.what_if_analysis.model_deployment.auto_scaling
+
+        # if auto_scaling_config is defined
+        if auto_scaling_config:
+            scaling_policy = oci.data_science.models.AutoScalingPolicy(
+                policy_type="AUTOSCALING",
+                auto_scaling_policies=[
+                    oci.data_science.models.ThresholdBasedAutoScalingPolicyDetails(
+                        auto_scaling_policy_type="THRESHOLD",
+                        rules=[
+                            oci.data_science.models.PredefinedMetricExpressionRule(
+                                metric_expression_rule_type="PREDEFINED_EXPRESSION",
+                                metric_type=auto_scaling_config.scaling_metric,
+                                scale_in_configuration=oci.data_science.models.PredefinedExpressionThresholdScalingConfiguration(
+                                    scaling_configuration_type="THRESHOLD",
+                                    threshold=auto_scaling_config.scale_in_threshold
+                                ),
+                                scale_out_configuration=oci.data_science.models.PredefinedExpressionThresholdScalingConfiguration(
+                                    scaling_configuration_type="THRESHOLD",
+                                    threshold=auto_scaling_config.scale_out_threshold
+                                )
+                            )],
+                        maximum_instance_count=auto_scaling_config.maximum_instance,
+                        minimum_instance_count=auto_scaling_config.minimum_instance,
+                        initial_instance_count=auto_scaling_config.minimum_instance)],
+                cool_down_in_seconds=auto_scaling_config.cool_down_in_seconds,
+                is_enabled=True)
+            logger.info(f"Using autoscaling {auto_scaling_config.scaling_metric} for creating MD")
+        else:
+            scaling_policy = FixedSizeScalingPolicy(instance_count=1)
+            logger.info("Using fixed size policy for creating MD")
+
+        model_configuration_details_object = ModelConfigurationDetails(
+            model_id=self.catalog_id,
+            instance_configuration=InstanceConfiguration(
+                instance_shape_name=initial_shape),
+            scaling_policy=scaling_policy,
+            bandwidth_mbps=20)
+
+        single_model_config = SingleModelDeploymentConfigurationDetails(
+            deployment_type='SINGLE_MODEL',
+            model_configuration_details=model_configuration_details_object
+        )
+
+        log_group = self.spec.what_if_analysis.model_deployment.log_group
+        log_id = self.spec.what_if_analysis.model_deployment.log_id
+
+        logs_configuration_details_object = CategoryLogDetails(
+            access=LogDetails(log_group_id=log_group,
+                              log_id=log_id),
+            predict=LogDetails(log_group_id=log_group,
+                               log_id=log_id))
+
+        model_deploy_configuration = CreateModelDeploymentDetails(
+            display_name=name,
+            description=description,
+            project_id=self.project_id,
+            compartment_id=self.compartment_id,
+            model_deployment_configuration_details=single_model_config,
+            category_log_details=logs_configuration_details_object)
+
+        if not self.test_mode:
+            auth = oci.auth.signers.get_resource_principals_signer()
+            data_science = DataScienceClient({}, signer=auth)
+            data_science_composite = DataScienceClientCompositeOperations(data_science)
+            model_deployment = data_science_composite.create_model_deployment_and_wait_for_state(
+                model_deploy_configuration,
+                wait_for_states=[
+                    "SUCCEEDED", "FAILED"])
+            self.deployment_info['work_request'] = model_deployment.data.id
+            logger.info(f"deployment metadata :{model_deployment.data}")
+            md = data_science.get_model_deployment(model_deployment_id=model_deployment.data.resources[0].identifier)
+            self.deployment_info['model_deployment_ocid'] = md.data.id
+            endpoint_url = md.data.model_deployment_url
+            self.deployment_info['model_deployment_endpoint'] = f"{endpoint_url}/predict"
+
+    def save_deployment_info(self):
+        output_dir = self.spec.output_directory.url
+        if ObjectStorageDetails.is_oci_path(output_dir):
+            storage_options = default_signer()
+        else:
+            storage_options = {}
+        write_data(
+            data=pd.DataFrame.from_dict(self.deployment_info),
+            filename=os.path.join(output_dir, "deployment_info.json"),
+            format="json",
+            storage_options=storage_options,
+            index=False,
+            indent=4,
+            orient="records"
+        )
+        write_simple_json(self.deployment_info, os.path.join(output_dir, "deployment_info.json"))
+        logger.info(f"Saved deployment info to {output_dir}")

ads/opctl/operator/lowcode/forecast/whatifserve/score.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import json
+import os
+from joblib import load
+import pandas as pd
+import numpy as np
+from functools import lru_cache
+import logging
+import ads
+from ads.opctl.operator.lowcode.common.utils import load_data
+from ads.opctl.operator.common.operator_config import InputData
+from ads.opctl.operator.lowcode.forecast.const import SupportedModels
+
+ads.set_auth("resource_principal")
+
+logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s', level=logging.INFO)
+logger_pred = logging.getLogger('model-prediction')
+logger_pred.setLevel(logging.INFO)
+logger_feat = logging.getLogger('input-features')
+logger_feat.setLevel(logging.INFO)
+
+"""
+   Inference script. This script is used for prediction by scoring server when schema is known.
+"""
+
+
+@lru_cache(maxsize=10)
+def load_model():
+    """
+    Loads model from the serialized format
+
+    Returns
+    -------
+    model:  a model instance on which predict API can be invoked
+    """
+    model_dir = os.path.dirname(os.path.realpath(__file__))
+    contents = os.listdir(model_dir)
+    model_file_name = "models.pickle"
+    if model_file_name in contents:
+        with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), model_file_name), "rb") as file:
+            model = load(file)
+    else:
+        raise Exception('{0} is not found in model directory {1}'.format(model_file_name, model_dir))
+    return model
+
+
+@lru_cache(maxsize=1)
+def fetch_data_type_from_schema(
+        input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
+    """
+    Returns data type information fetch from input_schema.json.
+
+    Parameters
+    ----------
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data_type: data type fetch from input_schema.json.
+
+    """
+    data_type = {}
+    if os.path.exists(input_schema_path):
+        schema = json.load(open(input_schema_path))
+        for col in schema['schema']:
+            data_type[col['name']] = col['dtype']
+    else:
+        print(
+            "input_schema has to be passed in in order to recover the same data type. pass `X_sample` in `ads.model.framework.sklearn_model.SklearnModel.prepare` function to generate the input_schema. Otherwise, the data type might be changed after serialization/deserialization.")
+    return data_type
+
+
+def deserialize(data, input_schema_path):
+    """
+    Deserialize json serialization data to data in original type when sent to predict.
+
+    Parameters
+    ----------
+    data: serialized input data.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data: deserialized input data.
+
+    """
+
+    # Add further data deserialization if needed
+    return data
+
+
+def pre_inference(data, input_schema_path):
+    """
+    Preprocess data
+
+    Parameters
+    ----------
+    data: Data format as expected by the predict API of the core estimator.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data: Data format after any processing.
+
+    """
+    return deserialize(data, input_schema_path)
+
+
+def post_inference(yhat):
+    """
+    Post-process the model results
+
+    Parameters
+    ----------
+    yhat: Data format after calling model.predict.
+
+    Returns
+    -------
+    yhat: Data format after any processing.
+
+    """
+    if isinstance(yhat, pd.core.frame.DataFrame):
+        yhat = yhat.values
+    if isinstance(yhat, np.ndarray):
+        yhat = yhat.tolist()
+    return yhat
+
+
+def get_forecast(future_df, model_name, series_id, model_object, date_col, target_column, target_cat_col, horizon):
+    date_col_name = date_col["name"]
+    date_col_format = date_col["format"]
+    future_df[target_cat_col] = future_df[target_cat_col].astype("str")
+    future_df[date_col_name] = pd.to_datetime(
+        future_df[date_col_name], format=date_col_format
+    )
+    if model_name == SupportedModels.AutoTS:
+        series_id_col = "Series"
+        full_data_indexed = future_df.rename(columns={target_cat_col: series_id_col})
+        additional_regressors = list(
+            set(full_data_indexed.columns) - {target_column, series_id_col, date_col_name}
+        )
+        future_reg = full_data_indexed.reset_index().pivot(
+            index=date_col_name,
+            columns=series_id_col,
+            values=additional_regressors,
+        )
+        pred_obj = model_object.predict(future_regressor=future_reg)
+        return pred_obj.forecast[series_id].tolist()
+    elif model_name == SupportedModels.Prophet and series_id in model_object:
+        model = model_object[series_id]
+        processed = future_df.rename(columns={date_col_name: 'ds', target_column: 'y'})
+        forecast = model.predict(processed)
+        return forecast['yhat'].tolist()
+    elif model_name == SupportedModels.NeuralProphet and series_id in model_object:
+        model = model_object[series_id]
+        model.restore_trainer()
+        accepted_regressors = list(model.config_regressors.regressors.keys())
+        data = future_df.rename(columns={date_col_name: 'ds', target_column: 'y'})
+        future = data[accepted_regressors + ["ds"]].reset_index(drop=True)
+        future["y"] = None
+        forecast = model.predict(future)
+        return forecast['yhat1'].tolist()
+    elif model_name == SupportedModels.Arima and series_id in model_object:
+        model = model_object[series_id]
+        future_df = future_df.set_index(date_col_name)
+        x_pred = future_df.drop(target_cat_col, axis=1)
+        yhat, conf_int = model.predict(
+            n_periods=horizon,
+            X=x_pred,
+            return_conf_int=True
+        )
+        yhat_clean = pd.DataFrame(yhat, index=yhat.index, columns=["yhat"])
+        return yhat_clean['yhat'].tolist()
+    elif model_name == SupportedModels.AutoMLX and series_id in model_object:
+        # automlx model
+        model = model_object[series_id]
+        x_pred = future_df.drop(target_cat_col, axis=1)
+        x_pred = x_pred.set_index(date_col_name)
+        forecast = model.forecast(
+            X=x_pred,
+            periods=horizon
+        )
+        return forecast[target_column].tolist()
+    else:
+        raise Exception(f"Invalid model object type: {type(model_object).__name__}.")
+
+
+def predict(data, model=load_model()) -> dict:
+    """
+    Returns prediction given the model and data to predict
+
+    Parameters
+    ----------
+    model: Model instance returned by load_model API
+    data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Panda DataFrame
+
+    Returns
+    -------
+    predictions: Output from scoring server
+        Format: { 'prediction': output from `model.predict` method }
+
+    """
+    assert model is not None, "Model is not loaded"
+
+    models = model["models"]
+    specs = model["spec"]
+    horizon = specs["horizon"]
+    model_name = specs["model"]
+    date_col = specs["datetime_column"]
+    target_column = specs["target_column"]
+    target_category_column = specs["target_category_columns"][0]
+
+    try:
+        input_data = InputData(**data["additional_data"])
+    except TypeError as e:
+        raise ValueError(f"Validation error: {e}")
+    additional_data = load_data(input_data)
+
+    unique_values = additional_data[target_category_column].unique()
+    forecasts = {}
+    for key in unique_values:
+        try:
+            s_id = str(key)
+            filtered = additional_data[additional_data[target_category_column] == key]
+            future = filtered.tail(horizon)
+            forecast = get_forecast(future, model_name, s_id, models, date_col,
+                                    target_column, target_category_column, horizon)
+            forecasts[s_id] = json.dumps(forecast)
+        except Exception as e:
+            raise RuntimeError(
+                f"An error occurred during prediction: {e}."
+                f" Please ensure the input data matches the format and structure of the data used during training.")
+
+    return {'prediction': json.dumps(forecasts)}

ads/telemetry/base.py

@@ -1,17 +1,18 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import logging
 
-from ads import set_auth
+import oci
+
 from ads.common import oci_client as oc
-from ads.common.auth import default_signer
+from ads.common.auth import default_signer, resource_principal
 from ads.config import OCI_RESOURCE_PRINCIPAL_VERSION
 
-
 logger = logging.getLogger(__name__)
+
+
 class TelemetryBase:
     """Base class for Telemetry Client."""
 
@@ -25,15 +26,21 @@ class TelemetryBase:
         namespace : str, optional
             Namespace of the OCI object storage bucket, by default None.
         """
+        # Use resource principal as authentication method if available,
+        # however, do not change the ADS authentication if user configured it by set_auth.
         if OCI_RESOURCE_PRINCIPAL_VERSION:
-            set_auth("resource_principal")
-        self._auth = default_signer()
-        self.os_client = oc.OCIClientFactory(**self._auth).object_storage
+            self._auth = resource_principal()
+        else:
+            self._auth = default_signer()
+        self.os_client: oci.object_storage.ObjectStorageClient = oc.OCIClientFactory(
+            **self._auth
+        ).object_storage
         self.bucket = bucket
         self._namespace = namespace
         self._service_endpoint = None
-        logger.debug(f"Initialized Telemetry. Namespace: {self.namespace}, Bucket: {self.bucket}")
-
+        logger.debug(
+            f"Initialized Telemetry. Namespace: {self.namespace}, Bucket: {self.bucket}"
+        )
 
     @property
     def namespace(self) -> str:
@@ -58,5 +65,5 @@ class TelemetryBase:
             Tenancy-specific endpoint.
         """
         if not self._service_endpoint:
-            self._service_endpoint = self.os_client.base_client.endpoint
+            self._service_endpoint = str(self.os_client.base_client.endpoint)
         return self._service_endpoint

ads/telemetry/client.py

@@ -1,17 +1,19 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 
 import logging
 import threading
+import traceback
 import urllib.parse
-import requests
-from requests import Response
-from .base import TelemetryBase
+from typing import Optional
+
+import oci
+
 from ads.config import DEBUG_TELEMETRY
 
+from .base import TelemetryBase
 
 logger = logging.getLogger(__name__)
 
@@ -32,7 +34,7 @@ class TelemetryClient(TelemetryBase):
     >>> import traceback
     >>> from ads.telemetry.client import TelemetryClient
     >>> AQUA_BUCKET = os.environ.get("AQUA_BUCKET", "service-managed-models")
-    >>> AQUA_BUCKET_NS = os.environ.get("AQUA_BUCKET_NS", "ociodscdev")
+    >>> AQUA_BUCKET_NS = os.environ.get("AQUA_BUCKET_NS", "namespace")
     >>> telemetry = TelemetryClient(bucket=AQUA_BUCKET, namespace=AQUA_BUCKET_NS)
     >>> telemetry.record_event_async(category="aqua/service/model", action="create") # records create action
     >>> telemetry.record_event_async(category="aqua/service/model/create", action="shape", detail="VM.GPU.A10.1")
@@ -45,7 +47,7 @@ class TelemetryClient(TelemetryBase):
 
     def record_event(
         self, category: str = None, action: str = None, detail: str = None, **kwargs
-    ) -> Response:
+    ) -> Optional[int]:
         """Send a head request to generate an event record.
 
         Parameters
@@ -62,23 +64,41 @@ class TelemetryClient(TelemetryBase):
 
         Returns
         -------
-        Response
+        int
+            The status code for the telemetry request.
+            200: The the object exists for the telemetry request
+            404: The the object does not exist for the telemetry request.
+            Note that for telemetry purpose, the object does not need to be exist.
+            `None` will be returned if the telemetry request failed.
         """
         try:
             if not category or not action:
                 raise ValueError("Please specify the category and the action.")
             if detail:
                 category, action = f"{category}/{action}", detail
+            # Here `endpoint`` is for debugging purpose
+            # For some federated/domain users, the `endpoint` may not be a valid URL
             endpoint = f"{self.service_endpoint}/n/{self.namespace}/b/{self.bucket}/o/telemetry/{category}/{action}"
-            headers = {"User-Agent": self._encode_user_agent(**kwargs)}
             logger.debug(f"Sending telemetry to endpoint: {endpoint}")
-            signer = self._auth["signer"]
-            response = requests.head(endpoint, auth=signer, headers=headers)
-            logger.debug(f"Telemetry status code: {response.status_code}")
-            return response
+
+            self.os_client.base_client.user_agent = self._encode_user_agent(**kwargs)
+            try:
+                response: oci.response.Response = self.os_client.head_object(
+                    namespace_name=self.namespace,
+                    bucket_name=self.bucket,
+                    object_name=f"telemetry/{category}/{action}",
+                )
+                logger.debug(f"Telemetry status: {response.status}")
+                return response.status
+            except oci.exceptions.ServiceError as ex:
+                if ex.status == 404:
+                    return ex.status
+                raise ex
         except Exception as e:
             if DEBUG_TELEMETRY:
                 logger.error(f"There is an error recording telemetry: {e}")
+                traceback.print_exc()
+            return None
 
     def record_event_async(
         self, category: str = None, action: str = None, detail: str = None, **kwargs