oracle-ads 2.12.2__py3-none-any.whl → 2.12.4__py3-none-any.whl

ads/model/deployment/model_deployment_infrastructure.py

@@ -57,6 +57,8 @@ class ModelDeploymentInfrastructure(Builder):
         The web concurrency of model deployment
     subnet_id: str
         The subnet id of model deployment
+    private_endpoint_id: str
+        The private endpoint id of model deployment
 
     Methods
     -------
@@ -84,6 +86,8 @@ class ModelDeploymentInfrastructure(Builder):
         Sets the web concurrency of model deployment
     with_subnet_id(subnet_id)
         Sets the subnet id of model deployment
+    with_private_endpoint_id(private_endpoint)
+        Sets the private endpoint id of model deployment
 
     Example
     -------
@@ -100,6 +104,7 @@ class ModelDeploymentInfrastructure(Builder):
     ...        .with_bandwidth_mbps(10)
     ...        .with_web_concurrency(10)
     ...        .with_subnet_id(<subnet_id>)
+    ...        .with_private_endpoint_id(<private_endpoint_id>)
     ...        .with_access_log(
     ...            log_group_id=<log_group_id>,
     ...            log_id=<log_id>
@@ -143,6 +148,7 @@ class ModelDeploymentInfrastructure(Builder):
     CONST_WEB_CONCURRENCY = "webConcurrency"
     CONST_STREAM_CONFIG_DETAILS = "streamConfigurationDetails"
     CONST_SUBNET_ID = "subnetId"
+    CONST_PRIVATE_ENDPOINT_ID = "privateEndpointId"
 
     attribute_map = {
         CONST_PROJECT_ID: "project_id",
@@ -159,6 +165,7 @@ class ModelDeploymentInfrastructure(Builder):
         CONST_LOG_GROUP_ID: "log_group_id",
         CONST_WEB_CONCURRENCY: "web_concurrency",
         CONST_SUBNET_ID: "subnet_id",
+        CONST_PRIVATE_ENDPOINT_ID: "private_endpoint_id",
     }
 
     shape_config_details_attribute_map = {
@@ -186,6 +193,7 @@ class ModelDeploymentInfrastructure(Builder):
         CONST_SHAPE_NAME: f"{MODEL_CONFIG_DETAILS_PATH}.instance_configuration.instance_shape_name",
         CONST_SHAPE_CONFIG_DETAILS: f"{MODEL_CONFIG_DETAILS_PATH}.instance_configuration.model_deployment_instance_shape_config_details",
         CONST_SUBNET_ID: f"{MODEL_CONFIG_DETAILS_PATH}.instance_configuration.subnet_id",
+        CONST_PRIVATE_ENDPOINT_ID: f"{MODEL_CONFIG_DETAILS_PATH}.instance_configuration.private_endpoint_id",
         CONST_REPLICA: f"{MODEL_CONFIG_DETAILS_PATH}.scaling_policy.instance_count",
         CONST_BANDWIDTH_MBPS: f"{MODEL_CONFIG_DETAILS_PATH}.bandwidth_mbps",
         CONST_ACCESS_LOG: "category_log_details.access",
@@ -613,6 +621,32 @@ class ModelDeploymentInfrastructure(Builder):
         """
         return self.get_spec(self.CONST_SUBNET_ID, None)
 
+    def with_private_endpoint_id(self, private_endpoint_id: str) -> "ModelDeploymentInfrastructure":
+        """Sets the private endpoint id of model deployment.
+
+        Parameters
+        ----------
+        private_endpoint_id : str
+            The private endpoint id of model deployment.
+
+        Returns
+        -------
+        ModelDeploymentInfrastructure
+            The ModelDeploymentInfrastructure instance (self).
+        """
+        return self.set_spec(self.CONST_PRIVATE_ENDPOINT_ID, private_endpoint_id)
+
+    @property
+    def private_endpoint_id(self) -> str:
+        """The model deployment private endpoint id.
+
+        Returns
+        -------
+        str
+            The model deployment private endpoint id.
+        """
+        return self.get_spec(self.CONST_PRIVATE_ENDPOINT_ID, None)
+
     def init(self, **kwargs) -> "ModelDeploymentInfrastructure":
         """Initializes a starter specification for the ModelDeploymentInfrastructure.
 

ads/model/generic_model.py

@@ -2262,6 +2262,7 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
         description: Optional[str] = None,
         deployment_instance_shape: Optional[str] = None,
         deployment_instance_subnet_id: Optional[str] = None,
+        deployment_instance_private_endpoint_id: Optional[str] = None,
         deployment_instance_count: Optional[int] = None,
         deployment_bandwidth_mbps: Optional[int] = None,
         deployment_log_group_id: Optional[str] = None,
@@ -2312,6 +2313,8 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
             The shape of the instance used for deployment.
         deployment_instance_subnet_id: (str, optional). Default to None.
             The subnet id of the instance used for deployment.
+        deployment_instance_private_endpoint_id: (str, optional). Default to None.
+            The private endpoint id of instance used for deployment.
         deployment_instance_count: (int, optional). Defaults to 1.
             The number of instance used for deployment.
         deployment_bandwidth_mbps: (int, optional). Defaults to 10.
@@ -2432,6 +2435,8 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
             or self.properties.deployment_image,
             deployment_instance_subnet_id=existing_infrastructure.subnet_id
             or self.properties.deployment_instance_subnet_id,
+            deployment_instance_private_endpoint_id=existing_infrastructure.private_endpoint_id
+            or self.properties.deployment_instance_private_endpoint_id,
         ).to_dict()
 
         property_dict.update(override_properties)
@@ -2465,6 +2470,7 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
             .with_shape_name(self.properties.deployment_instance_shape)
             .with_replica(self.properties.deployment_instance_count)
             .with_subnet_id(self.properties.deployment_instance_subnet_id)
+            .with_private_endpoint_id(self.properties.deployment_instance_private_endpoint_id)
         )
 
         web_concurrency = (
@@ -2611,6 +2617,7 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
         deployment_description: Optional[str] = None,
         deployment_instance_shape: Optional[str] = None,
         deployment_instance_subnet_id: Optional[str] = None,
+        deployment_instance_private_endpoint_id: Optional[str] = None,
         deployment_instance_count: Optional[int] = None,
         deployment_bandwidth_mbps: Optional[int] = None,
         deployment_log_group_id: Optional[str] = None,
@@ -2701,6 +2708,8 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
             The shape of the instance used for deployment.
         deployment_instance_subnet_id: (str, optional). Default to None.
             The subnet id of the instance used for deployment.
+        deployment_instance_private_endpoint_id: (str, optional). Default to None.
+            The private endpoint id of instance used for deployment.
         deployment_instance_count: (int, optional). Defaults to 1.
             The number of instance used for deployment.
         deployment_bandwidth_mbps: (int, optional). Defaults to 10.
@@ -2846,6 +2855,7 @@ class GenericModel(MetadataMixin, Introspectable, EvaluatorMixin):
             description=deployment_description,
             deployment_instance_shape=self.properties.deployment_instance_shape,
             deployment_instance_subnet_id=self.properties.deployment_instance_subnet_id,
+            deployment_instance_private_endpoint_id=self.properties.deployment_instance_private_endpoint_id,
             deployment_instance_count=self.properties.deployment_instance_count,
             deployment_bandwidth_mbps=self.properties.deployment_bandwidth_mbps,
             deployment_log_group_id=self.properties.deployment_log_group_id,

ads/model/model_properties.py

@@ -29,6 +29,7 @@ class ModelProperties(BaseProperties):
     overwrite_existing_artifact: bool = None
     deployment_instance_shape: str = None
     deployment_instance_subnet_id: str = None
+    deployment_instance_private_endpoint_id: str = None
     deployment_instance_count: int = None
     deployment_bandwidth_mbps: int = None
     deployment_log_group_id: str = None

ads/model/service/oci_datascience_model.py

@@ -278,6 +278,34 @@ class OCIDataScienceModel(
                 raise ModelArtifactNotFoundError()
         return {}
 
+    @check_for_model_id(
+        msg="Model needs to be restored before the archived artifact content can be accessed."
+    )
+    def restore_archived_model_artifact(
+            self, restore_model_for_hours_specified: Optional[int] = None
+    ) -> None:
+        """Restores the archived model artifact.
+
+        Parameters
+        ----------
+        model_id : str
+            The unique identifier of the model to restore.
+        restore_model_for_hours_specified : Optional[int]
+            The duration (in hours) for which the model should be restored.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ModelArtifactNotFoundError
+            If model artifact not found.
+        """
+        return self.client.restore_archived_model_artifact(
+            model_id=self.id,
+            restore_model_for_hours_specified=restore_model_for_hours_specified).headers["opc-work-request-id"]
+
     @check_for_model_id(
         msg="Model needs to be saved to the Model Catalog before the artifact content can be read."
     )

ads/opctl/operator/lowcode/anomaly/const.py

@@ -21,6 +21,23 @@ class SupportedModels(str, metaclass=ExtendedEnumMeta):
     EE = "ee"
     ISOLATIONFOREST = "isolationforest"
 
+    # point anomaly
+    DAGMM = "dagmm"
+    DEEP_POINT_ANOMALY_DETECTOR = "deep_point_anomaly_detector"
+    LSTM_ED = "lstm_ed"
+    SPECTRAL_RESIDUAL = "spectral_residual"
+    VAE = "vae"
+
+    # forecast_based
+    ARIMA = "arima"
+    ETS = "ets"
+    PROPHET = "prophet"
+    SARIMA = "sarima"
+
+    # changepoint
+    BOCPD = "bocpd"
+
+
 class NonTimeADSupportedModels(str, metaclass=ExtendedEnumMeta):
     """Supported non time-based anomaly detection models."""
 
@@ -29,7 +46,7 @@ class NonTimeADSupportedModels(str, metaclass=ExtendedEnumMeta):
     RandomCutForest = "randomcutforest"
     # TODO : Add DBScan
     # DBScan = "dbscan"
-    
+
 
 class TODSSubModels(str, metaclass=ExtendedEnumMeta):
     """Supported TODS sub models."""
@@ -61,6 +78,54 @@ TODS_MODEL_MAP = {
 }
 
 
+class MerlionADModels(str, metaclass=ExtendedEnumMeta):
+    """Supported Merlion AD sub models."""
+
+    # point anomaly
+    DAGMM = "dagmm"
+    DEEP_POINT_ANOMALY_DETECTOR = "deep_point_anomaly_detector"
+    LSTM_ED = "lstm_ed"
+    SPECTRAL_RESIDUAL = "spectral_residual"
+    VAE = "vae"
+
+    # forecast_based
+    ARIMA = "arima"
+    ETS = "ets"
+    PROPHET = "prophet"
+    SARIMA = "sarima"
+
+    # changepoint
+    BOCPD = "bocpd"
+
+
+MERLIONAD_IMPORT_MODEL_MAP = {
+    MerlionADModels.DAGMM: ".dagmm",
+    MerlionADModels.DEEP_POINT_ANOMALY_DETECTOR: ".deep_point_anomaly_detector",
+    MerlionADModels.LSTM_ED: ".lstm_ed",
+    MerlionADModels.SPECTRAL_RESIDUAL: ".spectral_residual",
+    MerlionADModels.VAE: ".vae",
+    MerlionADModels.ARIMA: ".forecast_based.arima",
+    MerlionADModels.ETS: ".forecast_based.ets",
+    MerlionADModels.PROPHET: ".forecast_based.prophet",
+    MerlionADModels.SARIMA: ".forecast_based.sarima",
+    MerlionADModels.BOCPD: ".change_point.bocpd",
+}
+
+
+MERLIONAD_MODEL_MAP = {
+    MerlionADModels.DAGMM: "DAGMM",
+    MerlionADModels.DEEP_POINT_ANOMALY_DETECTOR: "DeepPointAnomalyDetector",
+    MerlionADModels.LSTM_ED: "LSTMED",
+    MerlionADModels.SPECTRAL_RESIDUAL: "SpectralResidual",
+    MerlionADModels.VAE: "VAE",
+    MerlionADModels.ARIMA: "ArimaDetector",
+    MerlionADModels.ETS: "ETSDetector",
+    MerlionADModels.PROPHET: "ProphetDetector",
+    MerlionADModels.SARIMA: "SarimaDetector",
+    MerlionADModels.BOCPD: "BOCPD",
+}
+
+
 class SupportedMetrics(str, metaclass=ExtendedEnumMeta):
     UNSUPERVISED_UNIFY95 = "unsupervised_unify95"
     UNSUPERVISED_UNIFY95_LOG_LOSS = "unsupervised_unify95_log_loss"

ads/opctl/operator/lowcode/anomaly/model/anomaly_merlion.py

@@ -0,0 +1,161 @@
+#!/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 importlib
+
+import numpy as np
+import pandas as pd
+from merlion.post_process.threshold import AggregateAlarms
+from merlion.utils import TimeSeries
+
+from ads.common.decorator.runtime_dependency import runtime_dependency
+from ads.opctl.operator.lowcode.anomaly.const import (
+    MERLIONAD_IMPORT_MODEL_MAP,
+    MERLIONAD_MODEL_MAP,
+    OutputColumns,
+    SupportedModels,
+)
+
+from .anomaly_dataset import AnomalyOutput
+from .base_model import AnomalyOperatorBaseModel
+
+
+class AnomalyMerlionOperatorModel(AnomalyOperatorBaseModel):
+    """Class representing Merlion Anomaly Detection operator model."""
+
+    @runtime_dependency(
+        module="merlion",
+        err_msg=(
+            "Please run `pip3 install salesforce-merlion[all]` to "
+            "install the required packages."
+        ),
+    )
+    def _get_config_model(self, model_name):
+        """
+        Returns a dictionary with model names as keys and a list of model config and model object as values.
+
+        Parameters
+        ----------
+        model_name : str
+            model name from the Merlion model list.
+
+        Returns
+        -------
+        dict
+            A dictionary with model names as keys and a list of model config and model object as values.
+        """
+        model_config_map = {}
+        model_module = importlib.import_module(
+            name=MERLIONAD_IMPORT_MODEL_MAP.get(model_name),
+            package="merlion.models.anomaly",
+        )
+        model_config = getattr(
+            model_module, MERLIONAD_MODEL_MAP.get(model_name) + "Config"
+        )
+        model = getattr(model_module, MERLIONAD_MODEL_MAP.get(model_name))
+        model_config_map[model_name] = [model_config, model]
+        return model_config_map
+
+    def _build_model(self) -> AnomalyOutput:
+        """
+        Builds a Merlion anomaly detection model and trains it using the given data.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        AnomalyOutput
+            An AnomalyOutput object containing the anomaly detection results.
+        """
+        model_kwargs = self.spec.model_kwargs
+        anomaly_output = AnomalyOutput(date_column="index")
+        anomaly_threshold = model_kwargs.get("anomaly_threshold", 95)
+        model_config_map = {}
+        model_config_map = self._get_config_model(self.spec.model)
+
+        date_column = self.spec.datetime_column.name
+
+        anomaly_output = AnomalyOutput(date_column=date_column)
+        # model_objects = defaultdict(list)
+        for target, df in self.datasets.full_data_dict.items():
+            data = df.set_index(date_column)
+            data = TimeSeries.from_pd(data)
+            for model_name, (model_config, model) in model_config_map.items():
+                if self.spec.model == SupportedModels.BOCPD:
+                    model_config = model_config(**self.spec.model_kwargs)
+                else:
+                    model_config = model_config(
+                        **{
+                            **self.spec.model_kwargs,
+                            "threshold": AggregateAlarms(
+                                alm_threshold=model_kwargs.get("alm_threshold")
+                                if model_kwargs.get("alm_threshold")
+                                else None
+                            ),
+                        }
+                    )
+                if hasattr(model_config, "target_seq_index"):
+                    model_config.target_seq_index = df.columns.get_loc(
+                        self.spec.target_column
+                    )
+                model = model(model_config)
+
+                scores = model.train(train_data=data, anomaly_labels=None)
+                scores = scores.to_pd().reset_index()
+                scores["anom_score"] = (
+                    scores["anom_score"] - scores["anom_score"].min()
+                ) / (scores["anom_score"].max() - scores["anom_score"].min())
+
+                try:
+                    y_pred = model.get_anomaly_label(data)
+                    y_pred = (y_pred.to_pd().reset_index()["anom_score"] > 0).astype(
+                        int
+                    )
+                except Exception as e:
+                    y_pred = (
+                        scores["anom_score"]
+                        > np.percentile(
+                            scores["anom_score"],
+                            anomaly_threshold,
+                        )
+                    ).astype(int)
+
+                index_col = df.columns[0]
+
+                anomaly = pd.DataFrame(
+                    {index_col: df[index_col], OutputColumns.ANOMALY_COL: y_pred}
+                ).reset_index(drop=True)
+                score = pd.DataFrame(
+                    {
+                        index_col: df[index_col],
+                        OutputColumns.SCORE_COL: scores["anom_score"],
+                    }
+                ).reset_index(drop=True)
+                # model_objects[model_name].append(model)
+
+                anomaly_output.add_output(target, anomaly, score)
+        return anomaly_output
+
+    def _generate_report(self):
+        """Genreates a report for the model."""
+        import report_creator as rc
+
+        other_sections = [
+            rc.Heading("Selected Models Overview", level=2),
+            rc.Text(
+                "The following tables provide information regarding the chosen model."
+            ),
+        ]
+
+        model_description = rc.Text(
+            "The Merlion anomaly detection model is a full-stack automated machine learning system for anomaly detection."
+        )
+
+        return (
+            model_description,
+            other_sections,
+        )

ads/opctl/operator/lowcode/anomaly/model/autots.py

@@ -5,15 +5,17 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 from ads.common.decorator.runtime_dependency import runtime_dependency
+from ads.opctl import logger
 from ads.opctl.operator.lowcode.anomaly.const import OutputColumns
+
+from ..const import SupportedModels
 from .anomaly_dataset import AnomalyOutput
 from .base_model import AnomalyOperatorBaseModel
-from ..const import SupportedModels
-from ads.opctl import logger
 
 
 class AutoTSOperatorModel(AnomalyOperatorBaseModel):
     """Class representing AutoTS Anomaly Detection operator model."""
+
     model_mapping = {
         "isolationforest": "IsolationForest",
         "lof": "LOF",
@@ -22,30 +24,43 @@ class AutoTSOperatorModel(AnomalyOperatorBaseModel):
         "rolling_zscore": "rolling_zscore",
         "mad": "mad",
         "minmax": "minmax",
-        "iqr": "IQR"
+        "iqr": "IQR",
     }
 
     @runtime_dependency(
         module="autots",
         err_msg=(
-                "Please run `pip3 install autots` to "
-                "install the required dependencies for AutoTS."
+            "Please run `pip3 install autots` to "
+            "install the required dependencies for AutoTS."
         ),
     )
     def _build_model(self) -> AnomalyOutput:
         from autots.evaluator.anomaly_detector import AnomalyDetector
 
-        method = SupportedModels.ISOLATIONFOREST if self.spec.model == SupportedModels.AutoTS else self.spec.model
-        model_params = {"method": self.model_mapping[method],
-                        "transform_dict": self.spec.model_kwargs.get("transform_dict", {}),
-                        "output": self.spec.model_kwargs.get("output", "univariate"), "method_params": {}}
+        method = (
+            SupportedModels.ISOLATIONFOREST
+            if self.spec.model == SupportedModels.AutoTS
+            else self.spec.model
+        )
+        model_params = {
+            "method": self.model_mapping[method],
+            "transform_dict": self.spec.model_kwargs.get("transform_dict", {}),
+            "output": self.spec.model_kwargs.get("output", "univariate"),
+            "method_params": {},
+        }
         # Supported methods with contamination param
-        if method in [SupportedModels.ISOLATIONFOREST, SupportedModels.LOF, SupportedModels.EE]:
-            model_params["method_params"][
-                "contamination"] = self.spec.contamination if self.spec.contamination else 0.01
-        else:
-            if self.spec.contamination:
-                raise ValueError(f"The contamination parameter is not supported for the selected model \"{method}\"")
+        if method in [
+            SupportedModels.ISOLATIONFOREST,
+            SupportedModels.LOF,
+            SupportedModels.EE,
+        ]:
+            model_params["method_params"]["contamination"] = (
+                self.spec.contamination if self.spec.contamination else 0.01
+            )
+        elif self.spec.contamination:
+            raise ValueError(
+                f'The contamination parameter is not supported for the selected model "{method}"'
+            )
         logger.info(f"model params: {model_params}")
 
         model = AnomalyDetector(**model_params)

ads/opctl/operator/lowcode/anomaly/model/factory.py

@@ -4,14 +4,16 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 from ads.opctl.operator.lowcode.anomaly.utils import select_auto_model
+
+from ..const import NonTimeADSupportedModels, SupportedModels
+from ..operator_config import AnomalyOperatorConfig
 from .anomaly_dataset import AnomalyDatasets
+from .anomaly_merlion import AnomalyMerlionOperatorModel
 from .autots import AutoTSOperatorModel
 from .base_model import AnomalyOperatorBaseModel
 from .isolationforest import IsolationForestOperatorModel
 from .oneclasssvm import OneClassSVMOperatorModel
 from .randomcutforest import RandomCutForestOperatorModel
-from ..const import NonTimeADSupportedModels, SupportedModels
-from ..operator_config import AnomalyOperatorConfig
 
 
 class UnSupportedModelError(Exception):
@@ -48,7 +50,17 @@ class AnomalyOperatorModelFactory:
         SupportedModels.ZSCORE: AutoTSOperatorModel,
         SupportedModels.ROLLING_ZSCORE: AutoTSOperatorModel,
         SupportedModels.EE: AutoTSOperatorModel,
-        SupportedModels.MAD: AutoTSOperatorModel
+        SupportedModels.MAD: AutoTSOperatorModel,
+        SupportedModels.DAGMM: AnomalyMerlionOperatorModel,
+        SupportedModels.DEEP_POINT_ANOMALY_DETECTOR: AnomalyMerlionOperatorModel,
+        SupportedModels.LSTM_ED: AnomalyMerlionOperatorModel,
+        SupportedModels.SPECTRAL_RESIDUAL: AnomalyMerlionOperatorModel,
+        SupportedModels.VAE: AnomalyMerlionOperatorModel,
+        SupportedModels.ARIMA: AnomalyMerlionOperatorModel,
+        SupportedModels.ETS: AnomalyMerlionOperatorModel,
+        SupportedModels.PROPHET: AnomalyMerlionOperatorModel,
+        SupportedModels.SARIMA: AnomalyMerlionOperatorModel,
+        SupportedModels.BOCPD: AnomalyMerlionOperatorModel,
     }
 
     _NonTime_MAP = {

ads/opctl/operator/lowcode/anomaly/model/randomcutforest.py

@@ -36,7 +36,7 @@ class RandomCutForestOperatorModel(AnomalyOperatorBaseModel):
         # Set tree parameters
         num_trees = model_kwargs.get("num_trees", 200)
         shingle_size = model_kwargs.get("shingle_size", None)
-        anomaly_threshold = model_kwargs.get("anamoly_threshold", 95)
+        anomaly_threshold = model_kwargs.get("anomaly_threshold", 95)
 
         for target, df in self.datasets.full_data_dict.items():
             try:

ads/opctl/operator/lowcode/anomaly/schema.yaml

@@ -370,6 +370,16 @@ spec:
         - rolling_zscore
         - mad
         - ee
+        - dagmm
+        - deep_point_anomaly_detector
+        - lstm_ed
+        - spectral_residual
+        - vae
+        - arima
+        - ets
+        - sarima
+        - bocpd
+        - prophet
       meta:
         description: "The model to be used for anomaly detection"
 

ads/opctl/operator/lowcode/anomaly/utils.py

@@ -5,6 +5,7 @@
 
 import os
 
+import numpy as np
 import pandas as pd
 
 from ads.opctl import logger
@@ -27,6 +28,8 @@ def _build_metrics_df(y_true, y_pred, column_name):
     )
 
     metrics = {}
+    np.nan_to_num(y_true, copy=False)
+    np.nan_to_num(y_pred, copy=False)
     metrics[SupportedMetrics.RECALL] = recall_score(y_true, y_pred)
     metrics[SupportedMetrics.PRECISION] = precision_score(y_true, y_pred)
     metrics[SupportedMetrics.ACCURACY] = accuracy_score(y_true, y_pred)

ads/opctl/operator/lowcode/forecast/cmd.py

@@ -1,18 +1,12 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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/
 
 from typing import Dict
 
-import click
-
-from ads.opctl import logger
-from ads.opctl.operator.common.utils import _load_yaml_from_uri
 from ads.opctl.operator.common.operator_yaml_generator import YamlGenerator
-
-from .const import SupportedModels
+from ads.opctl.operator.common.utils import _load_yaml_from_uri
 
 
 def init(**kwargs: Dict) -> str:
@@ -39,7 +33,7 @@ def init(**kwargs: Dict) -> str:
     #     type=click.Choice(SupportedModels.values()),
     #     default=SupportedModels.Auto,
     # )
-    model_type = "auto"
+    model_type = "prophet"
 
     return YamlGenerator(
         schema=_load_yaml_from_uri(__file__.replace("cmd.py", "schema.yaml"))

ads/opctl/operator/lowcode/forecast/const.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
-# Copyright (c) 2023 Oracle and/or its affiliates.
+# 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/
 
 from ads.common.extended_enum import ExtendedEnumMeta
@@ -17,7 +16,7 @@ class SupportedModels(str, metaclass=ExtendedEnumMeta):
     LGBForecast = "lgbforecast"
     AutoMLX = "automlx"
     AutoTS = "autots"
-    Auto = "auto"
+    # Auto = "auto"
 
 
 class SpeedAccuracyMode(str, metaclass=ExtendedEnumMeta):
@@ -28,7 +27,7 @@ class SpeedAccuracyMode(str, metaclass=ExtendedEnumMeta):
     HIGH_ACCURACY = "HIGH_ACCURACY"
     BALANCED = "BALANCED"
     FAST_APPROXIMATE = "FAST_APPROXIMATE"
-    ratio = dict()
+    ratio = {}
     ratio[HIGH_ACCURACY] = 1  # 100 % data used for generating explanations
     ratio[BALANCED] = 0.5  # 50 % data used for generating explanations
     ratio[FAST_APPROXIMATE] = 0  # constant