oracle-ads 2.13.8__py3-none-any.whl → 2.13.9rc0__py3-none-any.whl

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

@@ -1,120 +0,0 @@
-#!/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 logging
-
-import numpy as np
-import pandas as pd
-import report_creator as rc
-
-from ads.common.decorator.runtime_dependency import runtime_dependency
-from ads.opctl import logger
-from ads.opctl.operator.lowcode.anomaly.const import OutputColumns
-
-from .anomaly_dataset import AnomalyOutput
-from .base_model import AnomalyOperatorBaseModel
-
-logging.getLogger("report_creator").setLevel(logging.WARNING)
-
-
-class RandomCutForestOperatorModel(AnomalyOperatorBaseModel):
-    """
-    Class representing Random Cut Forest Anomaly Detection operator model.
-    """
-
-    @runtime_dependency(
-        module="rrcf",
-        err_msg=(
-            "Please run `pip install rrcf` to "
-            "install the required dependencies for RandomCutForest."
-        ),
-    )
-    def _build_model(self) -> AnomalyOutput:
-        import rrcf
-
-        model_kwargs = self.spec.model_kwargs
-
-        anomaly_output = AnomalyOutput(date_column="index")
-
-        # Set tree parameters
-        num_trees = model_kwargs.get("num_trees", 200)
-        shingle_size = model_kwargs.get("shingle_size", None)
-        anomaly_threshold = model_kwargs.get("anomaly_threshold", 95)
-
-        for target, df in self.datasets.full_data_dict.items():
-            try:
-                if df.shape[0] == 1:
-                    raise ValueError("Dataset size must be greater than 1")
-                df_values = df[self.spec.target_column].astype(float).values
-
-                cal_shingle_size = (
-                    shingle_size
-                    if shingle_size
-                    else int(2 ** np.floor(np.log2(df.shape[0])) / 2)
-                )
-                points = np.vstack(list(rrcf.shingle(df_values, size=cal_shingle_size)))
-
-                sample_size_range = (1, points.shape[0])
-                n = points.shape[0]
-                avg_codisp = pd.Series(0.0, index=np.arange(n))
-                index = np.zeros(n)
-
-                forest = []
-                while len(forest) < num_trees:
-                    ixs = np.random.choice(n, size=sample_size_range, replace=False)
-                    trees = [rrcf.RCTree(points[ix], index_labels=ix) for ix in ixs]
-                    forest.extend(trees)
-
-                for tree in forest:
-                    codisp = pd.Series(
-                        {leaf: tree.codisp(leaf) for leaf in tree.leaves}
-                    )
-                    avg_codisp[codisp.index] += codisp
-                    np.add.at(index, codisp.index.values, 1)
-
-                avg_codisp /= index
-                avg_codisp.index = df.iloc[(cal_shingle_size - 1) :].index
-                avg_codisp = (avg_codisp - avg_codisp.min()) / (
-                    avg_codisp.max() - avg_codisp.min()
-                )
-
-                y_pred = (
-                    avg_codisp > np.percentile(avg_codisp, anomaly_threshold)
-                ).astype(int)
-
-                index_col = df.columns[0]
-
-                anomaly = pd.DataFrame(
-                    {index_col: y_pred.index, OutputColumns.ANOMALY_COL: y_pred}
-                ).reset_index(drop=True)
-                score = pd.DataFrame(
-                    {"index": avg_codisp.index, OutputColumns.SCORE_COL: avg_codisp}
-                ).reset_index(drop=True)
-
-                anomaly_output.add_output(target, anomaly, score)
-            except Exception as e:
-                logger.warning(f"Encountered Error: {e}. Skipping series {target}.")
-
-        return anomaly_output
-
-    def _generate_report(self):
-        """Generates the report."""
-
-        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 Random Cut Forest (RCF) is an unsupervised machine learning algorithm that is used for anomaly detection."
-            " It works by building an ensemble of binary trees (random cut trees) and using them to compute anomaly scores for data points."
-        )
-
-        return (
-            model_description,
-            other_sections,
-        )

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

@@ -1,119 +0,0 @@
-# #!/usr/bin/env python
-# # -*- coding: utf-8 -*--
-
-# # 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 ads.common.decorator.runtime_dependency import runtime_dependency
-# from .anomaly_dataset import AnomalyOutput
-
-# from ..const import (
-#     TODS_IMPORT_MODEL_MAP,
-#     TODS_MODEL_MAP,
-#     OutputColumns,
-#     TODS_DEFAULT_MODEL,
-# )
-# from .base_model import AnomalyOperatorBaseModel
-
-
-# class TODSOperatorModel(AnomalyOperatorBaseModel):
-#     """Class representing TODS Anomaly Detection operator model."""
-
-#     @runtime_dependency(
-#         module="tods",
-#         err_msg=(
-#             "Please run `pip3 install tods` to "
-#             "install the required dependencies for TODS."
-#         ),
-#     )
-#     def _build_model(self) -> pd.DataFrame:
-#         """
-#         Build the TODS model.
-
-#         Returns
-#         -------
-#             Tuple: model, predictions_train, and prediction_score_test
-#         """
-#         # Import the TODS module
-#         tods_module = importlib.import_module(
-#             name=TODS_IMPORT_MODEL_MAP.get(
-#                 self.spec.model_kwargs.get("sub_model", TODS_DEFAULT_MODEL)
-#             ),
-#             package="tods.sk_interface.detection_algorithm",
-#         )
-
-#         # Get the model kwargs
-#         model_kwargs = self.spec.model_kwargs
-#         sub_model = self.spec.model_kwargs.get("sub_model", TODS_DEFAULT_MODEL)
-#         model_kwargs.pop("sub_model", None)
-
-#         # Initialize variables
-#         models = {}
-#         predictions_train = {}
-#         prediction_score_train = {}
-#         predictions_test = {}
-#         prediction_score_test = {}
-#         date_column = self.spec.datetime_column.name
-#         anomaly_output = AnomalyOutput(date_column=date_column)
-
-#         # Iterate over the full_data_dict items
-#         for target, df in self.datasets.full_data_dict.items():
-#             # Instantiate the model
-#             model = getattr(tods_module, TODS_MODEL_MAP.get(sub_model))(**model_kwargs)
-
-#             # Fit the model
-#             model.fit(np.array(df[self.spec.target_column]).reshape(-1, 1))
-
-#             # Make predictions
-#             predictions_train[target] = model.predict(
-#                 np.array(df[self.spec.target_column]).reshape(-1, 1)
-#             )
-#             prediction_score_train[target] = model.predict_score(
-#                 np.array(df[self.spec.target_column]).reshape(-1, 1)
-#             )
-
-#             # Store the model and predictions in dictionaries
-#             models[target] = model
-
-#             anomaly = pd.DataFrame(
-#                 {
-#                     date_column: df[date_column],
-#                     OutputColumns.ANOMALY_COL: predictions_train[target],
-#                 }
-#             )
-#             score = pd.DataFrame(
-#                 {
-#                     date_column: df[date_column],
-#                     OutputColumns.SCORE_COL: prediction_score_train[target],
-#                 }
-#             )
-#             anomaly_output.add_output(target, anomaly, score)
-
-#         return anomaly_output
-
-#     def _generate_report(self):
-#         import report_creator as rc
-
-#         """The method that needs to be implemented on the particular model level."""
-#         selected_models_text = rc.Text(
-#             f"## Selected Models Overview \n "
-#             "The following tables provide information regarding the chosen model."
-#         )
-#         all_sections = [selected_models_text]
-
-#         model_description = rc.Text(
-#             "The tods model is a full-stack automated machine learning system for outlier detection "
-#             "on univariate / multivariate time-series data. It provides exhaustive modules for building "
-#             "machine learning-based outlier detection systems and wide range of algorithms."
-#         )
-#         other_sections = all_sections
-
-#         return (
-#             model_description,
-#             other_sections,
-#         )

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

@@ -1,127 +0,0 @@
-#!/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 os
-from dataclasses import dataclass, field
-from typing import Dict, List
-
-from ads.common.serializer import DataClassSerializable
-from ads.opctl.operator.common.operator_config import (
-    InputData,
-    OperatorConfig,
-    OutputDirectory,
-)
-from ads.opctl.operator.common.utils import _load_yaml_from_uri
-from ads.opctl.operator.lowcode.common.utils import find_output_dirname
-
-from .const import SupportedModels
-
-
-@dataclass(repr=True)
-class ValidationData(InputData):
-    """Class representing operator specification input data details."""
-
-
-@dataclass(repr=True)
-class DateTimeColumn(DataClassSerializable):
-    """Class representing operator specification date time column details."""
-
-    name: str = None
-    format: str = None
-
-
-@dataclass(repr=True)
-class TestData(InputData):
-    """Class representing operator specification test data details."""
-
-
-@dataclass(repr=True)
-class PreprocessingSteps(DataClassSerializable):
-    """Class representing preprocessing steps for operator."""
-
-    missing_value_imputation: bool = True
-    outlier_treatment: bool = False
-
-
-@dataclass(repr=True)
-class DataPreprocessor(DataClassSerializable):
-    """Class representing operator specification preprocessing details."""
-
-    enabled: bool = True
-    steps: PreprocessingSteps = field(default_factory=PreprocessingSteps)
-
-@dataclass(repr=True)
-class AnomalyOperatorSpec(DataClassSerializable):
-    """Class representing operator specification."""
-
-    input_data: InputData = field(default_factory=InputData)
-    datetime_column: DateTimeColumn = field(default_factory=DateTimeColumn)
-    test_data: TestData = field(default_factory=TestData)
-    validation_data: ValidationData = field(default_factory=ValidationData)
-    output_directory: OutputDirectory = field(default_factory=OutputDirectory)
-    preprocessing: DataPreprocessor = field(default_factory=DataPreprocessor)
-    report_file_name: str = None
-    report_title: str = None
-    report_theme: str = None
-    metrics_filename: str = None
-    test_metrics_filename: str = None
-    inliers_filename: str = None
-    outliers_filename: str = None
-    target_column: str = None
-    target_category_columns: List[str] = field(default_factory=list)
-    preprocessing: bool = None
-    generate_report: bool = None
-    generate_metrics: bool = None
-    generate_inliers: bool = None
-    model: str = None
-    model_kwargs: Dict = field(default_factory=dict)
-    contamination: float = None
-    subsample_report_data: bool = None
-
-    def __post_init__(self):
-        """Adjusts the specification details."""
-        self.output_directory = self.output_directory or OutputDirectory(url=find_output_dirname(self.output_directory))
-        self.report_file_name = self.report_file_name or "report.html"
-        self.report_theme = self.report_theme or "light"
-        self.inliers_filename = self.inliers_filename or "inliers.csv"
-        self.outliers_filename = self.outliers_filename or "outliers.csv"
-        self.test_metrics_filename = self.test_metrics_filename or "metrics.csv"
-        self.model = self.model or SupportedModels.Auto
-        self.generate_inliers = (
-            self.generate_inliers if self.generate_inliers is not None else False
-        )
-        self.model_kwargs = self.model_kwargs or dict()
-        self.preprocessing = (
-            self.preprocessing if self.preprocessing is not None else DataPreprocessor(enabled=True)
-        )
-
-@dataclass(repr=True)
-class AnomalyOperatorConfig(OperatorConfig):
-    """Class representing operator config.
-
-    Attributes
-    ----------
-    kind: str
-        The kind of the resource. For operators it is always - `operator`.
-    type: str
-        The type of the operator.
-    version: str
-        The version of the operator.
-    spec: AnomalyOperatorSpec
-        The operator specification.
-    """
-
-    kind: str = "operator"
-    type: str = "anomaly"
-    version: str = "v1"
-    spec: AnomalyOperatorSpec = field(default_factory=AnomalyOperatorSpec)
-
-    @classmethod
-    def _load_schema(cls) -> str:
-        """Loads operator schema."""
-        return _load_yaml_from_uri(
-            os.path.join(os.path.dirname(os.path.abspath(__file__)), "schema.yaml")
-        )