oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.10rc0__py3-none-any.whl

ads/opctl/operator/lowcode/anomaly/README.md

@@ -0,0 +1,207 @@
+# Anomaly Detection Operator
+
+Anomaly Detection is the identification of rare items, events, or observations in data that differ significantly from the expectation. This can be used for several scenarios like asset monitoring, maintenance and prognostic surveillance in industries such as utility, aviation and manufacturing.
+
+Below are the steps to configure and run the Anomaly Detection Operator on different resources.
+
+## 1. Prerequisites
+
+Follow the [CLI Configuration](https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/opctl/configure.html) steps from the ADS documentation. This step is mandatory as it sets up default values for different options while running the Anomaly Detection Operator on OCI Data Science jobs or OCI Data Flow applications. If you have previously done this and used a flexible shape, make sure to adjust `ml_job_config.ini` with shape config details and `docker_registry` information.
+
+- ocpus = 1
+- memory_in_gbs = 16
+- docker_registry = `<iad.ocir.io/namespace/>`
+
+## 2. Generating configs
+
+To generate starter configs, run the command below. This will create a list of YAML configs and place them in the `output` folder.
+
+```bash
+ads operator init -t anomaly --overwrite --output ~/anomaly/
+```
+
+The most important files expected to be generated are:
+
+- `anomaly.yaml`: Contains anomaly detection related configuration.
+- `backend_operator_local_python_config.yaml`: This includes a local backend configuration for running anomaly detection in a local environment. The environment should be set up manually before running the operator.
+- `backend_operator_local_container_config.yaml`: This includes a local backend configuration for running anomaly detection within a local container. The container should be built before running the operator. Please refer to the instructions below for details on how to accomplish this.
+- `backend_job_container_config.yaml`: Contains Data Science job-related config to run anomaly detection in a Data Science job within a container (BYOC) runtime. The container should be built and published before running the operator. Please refer to the instructions below for details on how to accomplish this.
+- `backend_job_python_config.yaml`: Contains Data Science job-related config to run anomaly detection in a Data Science job within a conda runtime. The conda should be built and published before running the operator.
+
+All generated configurations should be ready to use without the need for any additional adjustments. However, they are provided as starter kit configurations that can be customized as needed.
+
+## 3. Running anomaly detection on the local conda environment
+
+To run anomaly detection locally, create and activate a new conda environment (`ads-anomaly`). Install all the required libraries listed in the `environment.yaml` file.
+
+```yaml
+- report-creator
+- cerberus
+- "git+https://github.com/oracle/accelerated-data-science.git@feature/anomaly#egg=oracle-ads"
+```
+
+Please review the previously generated `anomaly.yaml` file using the `init` command, and make any necessary adjustments to the input and output file locations. By default, it assumes that the files should be located in the same folder from which the `init` command was executed.
+
+Use the command below to verify the anomaly detection config.
+
+```bash
+ads operator verify -f ~/anomaly/anomaly.yaml
+```
+
+Use the following command to run the anomaly detection within the `ads-anomaly` conda environment.
+
+```bash
+ads operator run -f ~/anomaly/anomaly.yaml -b local
+```
+
+The operator will run in your local environment without requiring any additional modifications.
+
+## 4. Running anomaly detection on the local container
+
+To run the anomaly detection operator within a local container, follow these steps:
+
+Use the command below to build the anomaly detection container.
+
+```bash
+ads operator build-image -t anomaly
+```
+
+This will create a new `anomaly:v1` image, with `/etc/operator` as the designated working directory within the container.
+
+
+Check the `backend_operator_local_container_config.yaml` config file. By default, it should have a `volume` section with the `.oci` configs folder mounted.
+
+```yaml
+volume:
+  - "/Users/<user>/.oci:/root/.oci"
+```
+
+Mounting the OCI configs folder is only required if an OCI Object Storage bucket will be used to store the input anomaly detection data or output anomaly detection result. The input/output folders can also be mounted to the container.
+
+```yaml
+volume:
+  - /Users/<user>/.oci:/root/.oci
+  - /Users/<user>/anomaly/data:/etc/operator/data
+  - /Users/<user>/anomaly/result:/etc/operator/result
+```
+
+The full config can look like:
+```yaml
+kind: operator.local
+spec:
+  image: anomaly:v1
+  volume:
+  - /Users/<user>/.oci:/root/.oci
+  - /Users/<user>/anomaly/data:/etc/operator/data
+  - /Users/<user>/anomaly/result:/etc/operator/result
+type: container
+version: v1
+```
+
+Run the anomaly detection within a container using the command below:
+
+```bash
+ads operator run -f ~/anomaly/anomaly.yaml --backend-config ~/anomaly/backend_operator_local_container_config.yaml
+```
+
+## 5. Running anomaly detection in the Data Science job within container runtime
+
+To execute the anomaly detection operator within a Data Science job using container runtime, please follow the steps outlined below:
+
+You can use the following command to build the anomaly detection container. This step can be skipped if you have already done this for running the operator within a local container.
+
+```bash
+ads operator build-image -t anomaly
+```
+
+This will create a new `anomaly:v1` image, with `/etc/operator` as the designated working directory within the container.
+
+Publish the `anomaly:v1` container to the [Oracle Container Registry](https://docs.public.oneportal.content.oci.oraclecloud.com/en-us/iaas/Content/Registry/home.htm). To become familiar with OCI, read the documentation links posted below.
+
+- [Access Container Registry](https://docs.public.oneportal.content.oci.oraclecloud.com/en-us/iaas/Content/Registry/Concepts/registryoverview.htm#access)
+- [Create repositories](https://docs.public.oneportal.content.oci.oraclecloud.com/en-us/iaas/Content/Registry/Tasks/registrycreatingarepository.htm#top)
+- [Push images](https://docs.public.oneportal.content.oci.oraclecloud.com/en-us/iaas/Content/Registry/Tasks/registrypushingimagesusingthedockercli.htm#Pushing_Images_Using_the_Docker_CLI)
+
+To publish `anomaly:v1` to OCR, use the command posted below:
+
+```bash
+ads operator publish-image anomaly:v1 --registry <iad.ocir.io/tenancy/>
+```
+
+After the container is published to OCR, it can be used within Data Science jobs service. Check the `backend_job_container_config.yaml` config file. It should contain pre-populated infrastructure and runtime sections. The runtime section should contain an image property, something like `image: iad.ocir.io/<tenancy>/anomaly:v1`. More details about supported options can be found in the ADS Jobs documentation - [Run a Container](https://accelerated-data-science.readthedocs.io/en/latest/user_guide/jobs/run_container.html).
+
+Adjust the `anomaly.yaml` config with proper input/output folders. When the anomaly detection is run in the Data Science job, it will not have access to local folders. Therefore, input data and output folders should be placed in the Object Storage bucket. Open the `anomaly.yaml` and adjust the following fields:
+
+```yaml
+input_data:
+  url: oci://bucket@namespace/anomaly/input_data/data.csv
+output_directory:
+  url: oci://bucket@namespace/anomaly/result/
+test_data:
+  url: oci://bucket@namespace/anomaly/input_data/test.csv
+```
+
+Run the anomaly detection on the Data Science jobs using the command posted below:
+
+```bash
+ads operator run -f ~/anomaly/anomaly.yaml --backend-config ~/anomaly/backend_job_container_config.yaml
+```
+
+The logs can be monitored using the `ads opctl watch` command.
+
+```bash
+ads opctl watch <OCID>
+```
+
+## 6. Running anomaly detection in the Data Science job within conda runtime
+
+To execute the anomaly detection operator within a Data Science job using conda runtime, please follow the steps outlined below:
+
+You can use the following command to build the anomaly detection conda environment.
+
+```bash
+ads operator build-conda -t anomaly
+```
+
+This will create a new `anomaly_v1` conda environment and place it in the folder specified within `ads opctl configure` command.
+
+Use the command below to Publish the `anomaly_v1` conda environment to the Object Storage bucket.
+
+```bash
+ads operator publish-conda -t anomaly
+```
+More details about configuring CLI can be found here - [Configuring CLI](https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/opctl/configure.html)
+
+
+After the conda environment is published to Object Storage, it can be used within Data Science jobs service. Check the `backend_job_python_config.yaml` config file. It should contain pre-populated infrastructure and runtime sections. The runtime section should contain a `conda` section.
+
+```yaml
+conda:
+  type: published
+  uri: oci://bucket@namespace/conda_environments/cpu/anomaly/1/anomaly_v1
+```
+
+More details about supported options can be found in the ADS Jobs documentation - [Run a Python Workload](https://accelerated-data-science.readthedocs.io/en/latest/user_guide/jobs/run_python.html).
+
+Adjust the `anomaly.yaml` config with proper input/output folders. When the anomaly detection is run in the Data Science job, it will not have access to local folders. Therefore, input data and output folders should be placed in the Object Storage bucket. Open the `anomaly.yaml` and adjust the following fields:
+
+```yaml
+input_data:
+  url: oci://bucket@namespace/anomaly/input_data/data.csv
+output_directory:
+  url: oci://bucket@namespace/anomaly/result/
+test_data:
+  url: oci://bucket@namespace/anomaly/input_data/test.csv
+```
+
+Run the anomaly detection on the Data Science jobs using the command posted below:
+
+```bash
+ads operator run -f ~/anomaly/anomaly.yaml --backend-config ~/anomaly/backend_job_python_config.yaml
+```
+
+The logs can be monitored using the `ads opctl watch` command.
+
+```bash
+ads opctl watch <OCID>
+```

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

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+
+# Copyright (c) 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
+import sys
+from typing import Dict, List
+
+import yaml
+
+from ads.opctl import logger
+from ads.opctl.operator.common.const import ENV_OPERATOR_ARGS
+from ads.opctl.operator.common.utils import _parse_input_args
+
+from .model.anomaly_dataset import AnomalyDatasets
+from .operator_config import AnomalyOperatorConfig
+
+
+def operate(operator_config: AnomalyOperatorConfig) -> None:
+    """Runs the anomaly detection operator."""
+    from .model.factory import AnomalyOperatorModelFactory
+
+    datasets = AnomalyDatasets(operator_config.spec)
+    try:
+        AnomalyOperatorModelFactory.get_model(
+            operator_config, datasets
+        ).generate_report()
+    except Exception as e:
+        if operator_config.spec.model == "auto":
+            logger.debug(
+                f"Failed to forecast with error {e.args}. Trying again with model `autots`."
+            )
+            operator_config.spec.model = "autots"
+            operator_config.spec.model_kwargs = {}
+            datasets = AnomalyDatasets(operator_config.spec)
+            try:
+                AnomalyOperatorModelFactory.get_model(
+                    operator_config, datasets
+                ).generate_report()
+            except Exception as ee:
+                logger.debug(
+                    f"Failed to backup forecast with error {ee.args}. Raising original error."
+                )
+                raise ee
+        else:
+            raise e
+
+
+def verify(spec: Dict) -> bool:
+    """Verifies the anomaly detection operator config."""
+    operator = AnomalyOperatorConfig.from_dict(spec)
+    msg_header = (
+        f"{'*' * 50} The operator config has been successfully verified {'*' * 50}"
+    )
+    print(msg_header)
+    print(operator.to_yaml())
+    print("*" * len(msg_header))
+
+
+def main(raw_args: List[str]):
+    """The entry point of the anomaly the operator."""
+    args, _ = _parse_input_args(raw_args)
+    if not args.file and not args.spec and not os.environ.get(ENV_OPERATOR_ARGS):
+        logger.info(
+            "Please specify -f[--file] or -s[--spec] or "
+            f"pass operator's arguments via {ENV_OPERATOR_ARGS} environment variable."
+        )
+        return
+
+    logger.info("-" * 100)
+    logger.info(
+        f"{'Running' if not args.verify else 'Verifying'} the anomaly detection operator."
+    )
+
+    # if spec provided as input string, then convert the string into YAML
+    yaml_string = ""
+    if args.spec or os.environ.get(ENV_OPERATOR_ARGS):
+        operator_spec_str = args.spec or os.environ.get(ENV_OPERATOR_ARGS)
+        try:
+            yaml_string = yaml.safe_dump(json.loads(operator_spec_str))
+        except json.JSONDecodeError:
+            yaml_string = yaml.safe_dump(yaml.safe_load(operator_spec_str))
+        except Exception:
+            yaml_string = operator_spec_str
+
+    operator_config = AnomalyOperatorConfig.from_yaml(
+        uri=args.file,
+        yaml_string=yaml_string,
+    )
+
+    logger.info(operator_config.to_yaml())
+
+    # run operator
+    if args.verify:
+        verify(operator_config)
+    else:
+        operate(operator_config)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 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
+
+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
+
+
+def init(**kwargs: Dict) -> str:
+    """
+    Generates operator config by the schema.
+
+    Properties
+    ----------
+    kwargs: (Dict, optional).
+        Additional key value arguments.
+
+        - type: str
+            The type of the operator.
+
+    Returns
+    -------
+    str
+        The YAML specification generated based on the schema.
+    """
+    logger.info("==== Generating anomaly detection configuration yaml file ====")
+
+    return YamlGenerator(
+        schema=_load_yaml_from_uri(__file__.replace("cmd.py", "schema.yaml"))
+    ).generate_example_dict(values={"type": kwargs.get("type")})

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

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2023, 2025 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 ExtendedEnum
+from ads.opctl.operator.lowcode.common.const import DataColumns
+
+
+class SupportedModels(ExtendedEnum):
+    """Supported anomaly models."""
+
+    AutoTS = "autots"
+    Auto = "auto"
+    IQR = "iqr"
+    LOF = "lof"
+    ZSCORE = "zscore"
+    ROLLING_ZSCORE = "rolling_zscore"
+    MAD = "mad"
+    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(ExtendedEnum):
+    """Supported non time-based anomaly detection models."""
+
+    OneClassSVM = "oneclasssvm"
+    IsolationForest = "isolationforest"
+    RandomCutForest = "randomcutforest"
+    # TODO : Add DBScan
+    # DBScan = "dbscan"
+
+
+class TODSSubModels(ExtendedEnum):
+    """Supported TODS sub models."""
+
+    OCSVM = "ocsvm"
+    DeepLog = "deeplog"
+    Telemanom = "telemanom"
+    IsolationForest = "isolationforest"
+    LSTMODetector = "lstmodetector"
+    KNN = "knn"
+
+
+TODS_IMPORT_MODEL_MAP = {
+    TODSSubModels.OCSVM: ".OCSVM_skinterface",
+    TODSSubModels.DeepLog: ".DeepLog_skinterface",
+    TODSSubModels.Telemanom: ".Telemanom_skinterface",
+    TODSSubModels.IsolationForest: ".IsolationForest_skinterface",
+    TODSSubModels.LSTMODetector: ".LSTMODetector_skinterface",
+    TODSSubModels.KNN: ".KNN_skinterface",
+}
+
+TODS_MODEL_MAP = {
+    TODSSubModels.OCSVM: "OCSVMSKI",
+    TODSSubModels.DeepLog: "DeepLogSKI",
+    TODSSubModels.Telemanom: "TelemanomSKI",
+    TODSSubModels.IsolationForest: "IsolationForestSKI",
+    TODSSubModels.LSTMODetector: "LSTMODetectorSKI",
+    TODSSubModels.KNN: "KNNSKI",
+}
+
+
+class MerlionADModels(ExtendedEnum):
+    """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(ExtendedEnum):
+    UNSUPERVISED_UNIFY95 = "unsupervised_unify95"
+    UNSUPERVISED_UNIFY95_LOG_LOSS = "unsupervised_unify95_log_loss"
+    UNSUPERVISED_N1_EXPERTS = "unsupervised_n-1_experts"
+    RECALL = "Recall"
+    PRECISION = "Precision"
+    ACCURACY = "Accuracy"
+    F1_SCORE = "f1_score"
+    FP = "False Positive"
+    FN = "False Negative"
+    TP = "True Positive"
+    TN = "True Negative"
+    ROC_AUC = "ROC_AUC"
+    PRC_AUC = "PRC_AUC"
+    MCC = "MCC"
+    MEAN_RECALL = "Mean Recall"
+    MEAN_PRECISION = "Mean Precision"
+    MEAN_ACCURACY = "Mean Accuracy"
+    MEAN_F1_SCORE = "Mean f1_score"
+    MEAN_ROC_AUC = "Mean ROC_AUC"
+    MEAN_PRC_AUC = "Mean PRC_AUC"
+    MEAN_MCC = "Mean MCC"
+    MEDIAN_RECALL = "Median Recall"
+    MEDIAN_PRECISION = "Median Precision"
+    MEDIAN_ACCURACY = "Median Accuracy"
+    MEDIAN_F1_SCORE = "Median f1_score"
+    MEDIAN_ROC_AUC = "Median ROC_AUC"
+    MEDIAN_PRC_AUC = "Median PRC_AUC"
+    MEDIAN_MCC = "Median MCC"
+    ELAPSED_TIME = "Elapsed Time"
+
+
+class OutputColumns(ExtendedEnum):
+    ANOMALY_COL = "anomaly"
+    SCORE_COL = "score"
+    Series = DataColumns.Series
+
+
+TODS_DEFAULT_MODEL = "ocsvm"
+SUBSAMPLE_THRESHOLD = 1000

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

@@ -0,0 +1,10 @@
+name: Anomaly
+channels:
+  - conda-forge
+dependencies:
+  - python=3.8
+  - pip
+  - pip:
+      - report-creator
+      - cerberus
+      - "oracle-ads[anomaly]"

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

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/

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

@@ -0,0 +1,146 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import pandas as pd
+
+from ads.opctl import logger
+from ads.opctl.operator.lowcode.anomaly.const import OutputColumns
+from ads.opctl.operator.lowcode.anomaly.utils import get_frequency_of_datetime
+from ads.opctl.operator.lowcode.common.data import AbstractData
+from ads.opctl.operator.lowcode.common.utils import (
+    default_signer,
+    merge_category_columns,
+)
+
+from ..operator_config import AnomalyOperatorSpec
+
+
+class AnomalyData(AbstractData):
+    def __init__(self, spec: AnomalyOperatorSpec):
+        super().__init__(spec=spec, name="input_data")
+
+
+class TestData(AbstractData):
+    def __init__(self, spec: AnomalyOperatorSpec):
+        super().__init__(spec=spec, name="test_data")
+
+
+class ValidationData(AbstractData):
+    def __init__(self, spec: AnomalyOperatorSpec):
+        super().__init__(spec=spec, name="validation_data")
+
+    def _ingest_data(self, spec):
+        self.X_valid_dict = dict()
+        self.y_valid_dict = dict()
+        for s_id, df in self.get_dict_by_series().items():
+            self.X_valid_dict[s_id] = df.drop([OutputColumns.ANOMALY_COL], axis=1)
+            self.y_valid_dict[s_id] = df[OutputColumns.ANOMALY_COL]
+
+
+class AnomalyDatasets:
+    def __init__(self, spec: AnomalyOperatorSpec):
+        """Instantiates the DataIO instance.
+
+        Properties
+        ----------
+        spec: AnomalyOperatorSpec
+            The anomaly operator spec.
+        """
+        self._data = AnomalyData(spec)
+        self.data = self._data.get_data_long()
+        self.full_data_dict = self._data.get_dict_by_series()
+        if spec.validation_data is not None:
+            self.valid_data = ValidationData(spec)
+            self.X_valid_dict = self.valid_data.X_valid_dict
+            self.y_valid_dict = self.valid_data.y_valid_dict
+
+    # Returns raw data based on the series_id i.e; the merged target_category_column value
+    def get_raw_data_by_cat(self, category):
+        return self._data.get_raw_data_by_cat(category)
+
+
+class AnomalyOutput:
+    def __init__(self, date_column):
+        self.category_map = dict()
+        self.date_column = date_column
+
+    def list_categories(self):
+        categories = list(self.category_map.keys())
+        categories.sort()
+        return categories
+
+    def add_output(self, category: str, anomalies: pd.DataFrame, scores: pd.DataFrame):
+        self.category_map[category] = (anomalies, scores)
+
+    def get_anomalies_by_cat(self, category: str):
+        return self.category_map[category][0]
+
+    def get_scores_by_cat(self, category: str):
+        return self.category_map[category][1]
+
+    def get_inliers_by_cat(self, category: str, data: pd.DataFrame):
+        anomaly = self.get_anomalies_by_cat(category)
+        scores = self.get_scores_by_cat(category)
+        inlier_indices = anomaly.index[anomaly[OutputColumns.ANOMALY_COL] == 0]
+        inliers = data.iloc[inlier_indices]
+        if scores is not None and not scores.empty and self.date_column != "index":
+            inliers = pd.merge(inliers, scores, on=self.date_column, how="inner")
+        else:
+            inliers = pd.merge(inliers, anomaly, left_index=True, right_index=True, how="inner")
+        return inliers
+
+    def get_outliers_by_cat(self, category: str, data: pd.DataFrame):
+        anomaly = self.get_anomalies_by_cat(category)
+        scores = self.get_scores_by_cat(category)
+        outliers_indices = anomaly.index[anomaly[OutputColumns.ANOMALY_COL] == 1]
+        outliers = data.iloc[outliers_indices]
+        if scores is not None and not scores.empty and self.date_column != "index":
+            outliers = pd.merge(outliers, scores, on=self.date_column, how="inner")
+        else:
+            outliers = pd.merge(outliers, anomaly, left_index=True, right_index=True, how="inner")
+        return outliers
+
+    def get_inliers(self, datasets):
+        inliers = pd.DataFrame()
+
+        for category in self.list_categories():
+            inliers = pd.concat(
+                [
+                    inliers,
+                    self.get_inliers_by_cat(category, datasets.get_raw_data_by_cat(category)),
+                ],
+                axis=0,
+                ignore_index=True,
+            )
+        return inliers
+
+    def get_outliers(self, datasets):
+        outliers = pd.DataFrame()
+
+        for category in self.list_categories():
+            outliers = pd.concat(
+                [
+                    outliers,
+                    self.get_outliers_by_cat(category, datasets.get_raw_data_by_cat(category)),
+                ],
+                axis=0,
+                ignore_index=True,
+            )
+        return outliers
+
+    def get_scores(self, target_category_columns):
+        if target_category_columns is None:
+            return self.get_scores_by_cat(self.list_categories()[0])
+
+        scores = pd.DataFrame()
+        for category in self.list_categories():
+            score = self.get_scores_by_cat(category)
+            score[target_category_columns[0]] = category
+            scores = pd.concat([scores, score], axis=0, ignore_index=True)
+        return scores
+
+    def get_num_anomalies_by_cat(self, category: str):
+        return (self.category_map[category][0][OutputColumns.ANOMALY_COL] == 1).sum()