model segregation, score to be normalized, tests enabled, overlapping meethods removed

Author: codeloop

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

@@ -5,19 +5,16 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import random
+
 from ads.common.extended_enum import ExtendedEnumMeta
 from ads.opctl.operator.lowcode.common.const import DataColumns
-from merlion.models.anomaly import autoencoder, deep_point_anomaly_detector, isolation_forest, spectral_residual, windstats, windstats_monthly
-from merlion.models.anomaly.change_point import bocpd
-from merlion.models.forecast import prophet
 
 
 class SupportedModels(str, metaclass=ExtendedEnumMeta):
     """Supported anomaly models."""
 
     AutoTS = "autots"
     Auto = "auto"
-    MerilonAD = "merlion_ad"
     IQR = "iqr"
     LOF = "lof"
     ZSCORE = "zscore"
@@ -26,6 +23,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."""
 
@@ -34,7 +48,7 @@ class NonTimeADSupportedModels(str, metaclass=ExtendedEnumMeta):
     RandomCutForest = "randomcutforest"
     # TODO : Add DBScan
     # DBScan = "dbscan"
-    
+
 
 class TODSSubModels(str, metaclass=ExtendedEnumMeta):
     """Supported TODS sub models."""
@@ -66,81 +80,51 @@ class TODSSubModels(str, metaclass=ExtendedEnumMeta):
 }
 
 
-class MerlionADSubmodels(str, metaclass=ExtendedEnumMeta):
+class MerlionADModels(str, metaclass=ExtendedEnumMeta):
     """Supported Merlion AD sub models."""
 
     # point anomaly
-    AUTOENCODER = "autoencoder"
     DAGMM = "dagmm"
-    DBL = "dbl"
     DEEP_POINT_ANOMALY_DETECTOR = "deep_point_anomaly_detector"
-    ISOLATION_FOREST = "isolation_forest"
-    LOF = "lof"
     LSTM_ED = "lstm_ed"
-    # RANDOM_CUT_FOREST = "random_cut_forest"
     SPECTRAL_RESIDUAL = "spectral_residual"
-    STAT_RESIDUAL = "stat_residual"
     VAE = "vae"
-    WINDSTATS = "windstats"
-    WINDSTATS_MONTHLY = "windstats_monthly"
-    ZMS = "zms"
 
     # forecast_based
     ARIMA = "arima"
     ETS = "ets"
-    MSES = "mses"
     PROPHET = "prophet"
     SARIMA = "sarima"
 
-    #changepoint
+    # changepoint
     BOCPD = "bocpd"
 
 
 MERLIONAD_IMPORT_MODEL_MAP = {
-    MerlionADSubmodels.AUTOENCODER: ".autoendcoder",
-    MerlionADSubmodels.DAGMM: ".dagmm",
-    MerlionADSubmodels.DBL: ".dbl",
-    MerlionADSubmodels.DEEP_POINT_ANOMALY_DETECTOR: ".deep_point_anomaly_detector",
-    MerlionADSubmodels.ISOLATION_FOREST: ".isolation_forest",
-    MerlionADSubmodels.LOF: ".lof",
-    MerlionADSubmodels.LSTM_ED: ".lstm_ed",
-    # MerlionADSubmodels.RANDOM_CUT_FOREST: ".random_cut_forest",
-    MerlionADSubmodels.SPECTRAL_RESIDUAL: ".spectral_residual",
-    MerlionADSubmodels.STAT_RESIDUAL: ".stat_residual",
-    MerlionADSubmodels.VAE: ".vae",
-    MerlionADSubmodels.WINDSTATS: ".windstats",
-    MerlionADSubmodels.WINDSTATS_MONTHLY: ".windstats_monthly",
-    MerlionADSubmodels.ZMS: ".zms",
-    MerlionADSubmodels.ARIMA: ".forecast_based.arima",
-    MerlionADSubmodels.ETS: ".forecast_based.ets",
-    MerlionADSubmodels.MSES: ".forecast_based.mses",
-    MerlionADSubmodels.PROPHET: ".forecast_based.prophet",
-    MerlionADSubmodels.SARIMA: ".forecast_based.sarima",
-    MerlionADSubmodels.BOCPD: ".change_point.bocpd",
+    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 = {
-    MerlionADSubmodels.AUTOENCODER: "AutoEncoder",
-    MerlionADSubmodels.DAGMM: "DAGMM",
-    MerlionADSubmodels.DBL: "DynamicBaseline",
-    MerlionADSubmodels.DEEP_POINT_ANOMALY_DETECTOR: "DeepPointAnomalyDetector",
-    MerlionADSubmodels.ISOLATION_FOREST: "IsolationForest",
-    MerlionADSubmodels.LOF: "LOF",
-    MerlionADSubmodels.LSTM_ED: "LSTMED",
-    # MerlionADSubmodels.RANDOM_CUT_FOREST: "RandomCutForest",
-    MerlionADSubmodels.SPECTRAL_RESIDUAL: "SpectralResidual",
-    MerlionADSubmodels.STAT_RESIDUAL: "StatThreshold",
-    MerlionADSubmodels.VAE: "VAE",
-    MerlionADSubmodels.WINDSTATS: "WindStats",
-    MerlionADSubmodels.WINDSTATS_MONTHLY: "MonthlyWindStats",
-    MerlionADSubmodels.ZMS: "ZMS",
-    MerlionADSubmodels.ARIMA: "ArimaDetector",
-    MerlionADSubmodels.ETS: "ETSDetector",
-    MerlionADSubmodels.MSES: "MSESDetector",
-    MerlionADSubmodels.PROPHET: "ProphetDetector",
-    MerlionADSubmodels.SARIMA: "SarimaDetector",
-    MerlionADSubmodels.BOCPD: "BOCPD",
+    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",
 }
 
 
@@ -182,6 +166,5 @@ class OutputColumns(str, metaclass=ExtendedEnumMeta):
     Series = DataColumns.Series
 
 
-MERLION_DEFAULT_MODEL = "prophet"
 TODS_DEFAULT_MODEL = "ocsvm"
 SUBSAMPLE_THRESHOLD = 1000

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

@@ -11,7 +11,6 @@
 
 from ads.common.decorator.runtime_dependency import runtime_dependency
 from ads.opctl.operator.lowcode.anomaly.const import (
-    MERLION_DEFAULT_MODEL,
     MERLIONAD_IMPORT_MODEL_MAP,
     MERLIONAD_MODEL_MAP,
     OutputColumns,
@@ -31,31 +30,30 @@ class AnomalyMerlionOperatorModel(AnomalyOperatorBaseModel):
             "install the required packages."
         ),
     )
-    def _get_config_model(self, model_list):
+    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_list : list
-            A list of model names.
+        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 = {}
-        for model_name in model_list:
-            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]
+        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:
@@ -75,66 +73,57 @@ def _build_model(self) -> AnomalyOutput:
         anomaly_output = AnomalyOutput(date_column="index")
         anomaly_threshold = model_kwargs.get("anomaly_threshold", 95)
         model_config_map = {}
-        if model_kwargs.get("sub_model", None):
-            model_config_map = self._get_config_model(model_kwargs.get("sub_model"))
-        else:
-            from merlion.models.anomaly.forecast_based.prophet import (  # noqa: I001
-                ProphetDetector,
-                ProphetDetectorConfig,
-            )
-
-            model_config_map[MERLION_DEFAULT_MODEL] = [
-                ProphetDetectorConfig,
-                ProphetDetector,
-            ]
-
-            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():
-                    model_config = model_config(**self.spec.model_kwargs)
-                    if hasattr(model_config, "target_seq_index"):
-                        model_config.target_seq_index = df.columns.get_loc(
-                            self.spec.target_column
+        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():
+                model_config = model_config(**self.spec.model_kwargs)
+                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,
                         )
-                    model = model(model_config)
-
-                    scores = model.train(train_data=data, anomaly_labels=None)
-
-                    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.to_pd().reset_index()["anom_score"]
-                            > np.percentile(
-                                scores.to_pd().reset_index()["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.to_pd().reset_index()[
-                                "anom_score"
-                            ],
-                        }
-                    ).reset_index(drop=True)
-                    # model_objects[model_name].append(model)
-
-                    anomaly_output.add_output(target, anomaly, score)
+                    ).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):

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

@@ -51,7 +51,16 @@ class AnomalyOperatorModelFactory:
         SupportedModels.ROLLING_ZSCORE: AutoTSOperatorModel,
         SupportedModels.EE: AutoTSOperatorModel,
         SupportedModels.MAD: AutoTSOperatorModel,
-        SupportedModels.MerilonAD: AnomalyMerlionOperatorModel,
+        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/schema.yaml

@@ -370,7 +370,16 @@ spec:
         - rolling_zscore
         - mad
         - ee
-        - merlion_ad
+        - 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)