oracle-ads 2.11.14__py3-none-any.whl → 2.11.15__py3-none-any.whl

ads/aqua/modeldeployment/deployment.py

@@ -1,31 +1,27 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # 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 logging
 from typing import Dict, List, Union
 
-from oci.data_science.models import ModelDeployment
-
 from ads.aqua.app import AquaApp, logger
 from ads.aqua.common.enums import (
-    Tags,
-    InferenceContainerParamType,
-    InferenceContainerType,
     InferenceContainerTypeFamily,
+    Tags,
 )
 from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
 from ads.aqua.common.utils import (
+    get_combined_params,
     get_container_config,
     get_container_image,
+    get_container_params_type,
     get_model_by_reference_paths,
     get_ocid_substring,
-    get_combined_params,
     get_params_dict,
     get_params_list,
     get_resource_name,
+    get_restricted_params_by_container,
     load_config,
 )
 from ads.aqua.constants import (
@@ -43,10 +39,6 @@ from ads.aqua.modeldeployment.entities import (
     AquaDeploymentDetail,
     ContainerSpec,
 )
-from ads.aqua.modeldeployment.constants import (
-    VLLMInferenceRestrictedParams,
-    TGIInferenceRestrictedParams,
-)
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.common.utils import get_log_links
 from ads.config import (
@@ -187,24 +179,24 @@ class AquaDeploymentApp(AquaApp):
                 model_name = aqua_model.custom_metadata_list.get(
                     FineTuneCustomMetadata.FINE_TUNE_SOURCE_NAME
                 ).value
-            except:
+            except ValueError as err:
                 raise AquaValueError(
                     f"Either {FineTuneCustomMetadata.FINE_TUNE_SOURCE} or {FineTuneCustomMetadata.FINE_TUNE_SOURCE_NAME} is missing "
                     f"from custom metadata for the model {config_source_id}"
-                )
+                ) from err
 
         # set up env vars
         if not env_var:
-            env_var = dict()
+            env_var = {}
 
         try:
             model_path_prefix = aqua_model.custom_metadata_list.get(
                 MODEL_BY_REFERENCE_OSS_PATH_KEY
             ).value.rstrip("/")
-        except ValueError:
+        except ValueError as err:
             raise AquaValueError(
                 f"{MODEL_BY_REFERENCE_OSS_PATH_KEY} key is not available in the custom metadata field."
-            )
+            ) from err
 
         if ObjectStorageDetails.is_oci_path(model_path_prefix):
             os_path = ObjectStorageDetails.from_path(model_path_prefix)
@@ -219,7 +211,7 @@ class AquaDeploymentApp(AquaApp):
 
             if not fine_tune_output_path:
                 raise AquaValueError(
-                    f"Fine tuned output path is not available in the model artifact."
+                    "Fine tuned output path is not available in the model artifact."
                 )
 
             os_path = ObjectStorageDetails.from_path(fine_tune_output_path)
@@ -232,7 +224,7 @@ class AquaDeploymentApp(AquaApp):
             container_type_key = aqua_model.custom_metadata_list.get(
                 AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME
             ).value
-        except ValueError:
+        except ValueError as err:
             message = (
                 f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the custom metadata field "
                 f"for model {aqua_model.id}."
@@ -242,7 +234,7 @@ class AquaDeploymentApp(AquaApp):
                 raise AquaValueError(
                     f"{message}. For unverified Aqua models, container_family parameter should be "
                     f"set and value can be one of {', '.join(InferenceContainerTypeFamily.values())}."
-                )
+                ) from err
             container_type_key = container_family
         try:
             # Check if the container override flag is set. If set, then the user has chosen custom image
@@ -282,11 +274,12 @@ class AquaDeploymentApp(AquaApp):
         )  # Give precendece to the input parameter
 
         deployment_config = self.get_deployment_config(config_source_id)
-        vllm_params = (
+
+        config_params = (
             deployment_config.get("configuration", UNKNOWN_DICT)
             .get(instance_shape, UNKNOWN_DICT)
             .get("parameters", UNKNOWN_DICT)
-            .get(InferenceContainerParamType.PARAM_TYPE_VLLM, UNKNOWN)
+            .get(get_container_params_type(container_type_key), UNKNOWN)
         )
 
         # validate user provided params
@@ -301,7 +294,7 @@ class AquaDeploymentApp(AquaApp):
                     f"and cannot be overridden or are invalid."
                 )
 
-        deployment_params = get_combined_params(vllm_params, user_params)
+        deployment_params = get_combined_params(config_params, user_params)
 
         if deployment_params:
             params = f"{params} {deployment_params}"
@@ -429,7 +422,7 @@ class AquaDeploymentApp(AquaApp):
                     # tracks unique deployments that were listed in the user compartment
                     # we arbitrarily choose last 8 characters of OCID to identify MD in telemetry
                     self.telemetry.record_event_async(
-                        category=f"aqua/deployment",
+                        category="aqua/deployment",
                         action="list",
                         detail=get_ocid_substring(deployment_id, key_len=8),
                         value=state,
@@ -570,32 +563,27 @@ class AquaDeploymentApp(AquaApp):
                 f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the custom metadata field for model {model_id}."
             )
 
-        if container_type_key:
-            container_type_key = container_type_key.lower()
-            if container_type_key in InferenceContainerTypeFamily.values():
-                deployment_config = self.get_deployment_config(model_id)
-                config_parameters = (
-                    deployment_config.get("configuration", UNKNOWN_DICT)
-                    .get(instance_shape, UNKNOWN_DICT)
-                    .get("parameters", UNKNOWN_DICT)
+        if (
+            container_type_key
+            and container_type_key in InferenceContainerTypeFamily.values()
+        ):
+            deployment_config = self.get_deployment_config(model_id)
+            config_params = (
+                deployment_config.get("configuration", UNKNOWN_DICT)
+                .get(instance_shape, UNKNOWN_DICT)
+                .get("parameters", UNKNOWN_DICT)
+                .get(get_container_params_type(container_type_key), UNKNOWN)
+            )
+            if config_params:
+                params_list = get_params_list(config_params)
+                restricted_params_set = get_restricted_params_by_container(
+                    container_type_key
                 )
-                if InferenceContainerType.CONTAINER_TYPE_VLLM in container_type_key:
-                    params = config_parameters.get(
-                        InferenceContainerParamType.PARAM_TYPE_VLLM, UNKNOWN
-                    )
-                elif InferenceContainerType.CONTAINER_TYPE_TGI in container_type_key:
-                    params = config_parameters.get(
-                        InferenceContainerParamType.PARAM_TYPE_TGI, UNKNOWN
-                    )
-                else:
-                    params = UNKNOWN
-                    logger.debug(
-                        f"Default inference parameters are not available for the model {model_id} and "
-                        f"instance {instance_shape}."
-                    )
-                if params:
-                    # account for param that can have --arg but no values, e.g. --trust-remote-code
-                    default_params.extend(get_params_list(params))
+
+                # remove restricted params from the list as user cannot override them during deployment
+                for params in params_list:
+                    if params.split()[0] not in restricted_params_set:
+                        default_params.append(params)
 
         return default_params
 
@@ -629,7 +617,7 @@ class AquaDeploymentApp(AquaApp):
                 container_type_key = model.custom_metadata_list.get(
                     AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME
                 ).value
-            except ValueError:
+            except ValueError as err:
                 message = (
                     f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the custom metadata field "
                     f"for model {model_id}."
@@ -640,7 +628,7 @@ class AquaDeploymentApp(AquaApp):
                     raise AquaValueError(
                         f"{message}. For unverified Aqua models, container_family parameter should be "
                         f"set and value can be one of {', '.join(InferenceContainerTypeFamily.values())}."
-                    )
+                    ) from err
                 container_type_key = container_family
 
             container_config = get_container_config()
@@ -658,7 +646,7 @@ class AquaDeploymentApp(AquaApp):
                 f"Parameters {restricted_params} are set by Aqua "
                 f"and cannot be overridden or are invalid."
             )
-        return dict(valid=True)
+        return {"valid": True}
 
     @staticmethod
     def _find_restricted_params(
@@ -667,8 +655,7 @@ class AquaDeploymentApp(AquaApp):
         container_family: str,
     ) -> List[str]:
         """Returns a list of restricted params that user chooses to override when creating an Aqua deployment.
-        The default parameters coming from the container index json file cannot be overridden. In addition to this,
-        a set of parameters maintained in
+        The default parameters coming from the container index json file cannot be overridden.
 
         Parameters
         ----------
@@ -689,18 +676,9 @@ class AquaDeploymentApp(AquaApp):
             default_params_dict = get_params_dict(default_params)
             user_params_dict = get_params_dict(user_params)
 
-            for key, items in user_params_dict.items():
-                if (
-                    key in default_params_dict
-                    or (
-                        InferenceContainerType.CONTAINER_TYPE_VLLM in container_family
-                        and key in VLLMInferenceRestrictedParams
-                    )
-                    or (
-                        InferenceContainerType.CONTAINER_TYPE_TGI in container_family
-                        and key in TGIInferenceRestrictedParams
-                    )
-                ):
-                    restricted_params.append(key.lstrip("--"))
+            restricted_params_set = get_restricted_params_by_container(container_family)
+            for key, _items in user_params_dict.items():
+                if key in default_params_dict or key in restricted_params_set:
+                    restricted_params.append(key.lstrip("-"))
 
         return restricted_params

ads/opctl/operator/common/operator_config.py

@@ -28,6 +28,7 @@ class InputData(DataClassSerializable):
     limit: int = None
     sql: str = None
     table_name: str = None
+    vault_secret_id: str = None
 
 
 @dataclass(repr=True)

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

@@ -58,7 +58,7 @@ The operator will run in your local environment without requiring any additional
 
 ## 4. Running anomaly detection on the local container
 
-To run the anomaly detection detection operator within a local container, follow these steps:
+To run the anomaly detection operator within a local container, follow these steps:
 
 Use the command below to build the anomaly detection container.
 
@@ -106,7 +106,7 @@ ads operator run -f ~/anomaly/anomaly.yaml --backend-config ~/anomaly/backend_op
 
 ## 5. Running anomaly detection in the Data Science job within container runtime
 
-To execute the anomaly detection detection operator within a Data Science job using container runtime, please follow the steps outlined below:
+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.
 
@@ -155,7 +155,7 @@ ads opctl watch <OCID>
 
 ## 6. Running anomaly detection in the Data Science job within conda runtime
 
-To execute the anomaly detection detection operator within a Data Science job using conda runtime, please follow the steps outlined below:
+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.
 

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

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
 
 # 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/
@@ -15,7 +14,7 @@ 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, AnomalyData
+from .model.anomaly_dataset import AnomalyDatasets
 from .operator_config import AnomalyOperatorConfig
 
 
@@ -34,7 +33,7 @@ def operate(operator_config: AnomalyOperatorConfig) -> None:
                 f"Failed to forecast with error {e.args}. Trying again with model `autots`."
             )
             operator_config.spec.model = "autots"
-            operator_config.spec.model_kwargs = dict()
+            operator_config.spec.model_kwargs = {}
             datasets = AnomalyDatasets(operator_config.spec)
             try:
                 AnomalyOperatorModelFactory.get_model(
@@ -44,12 +43,12 @@ def operate(operator_config: AnomalyOperatorConfig) -> None:
                 logger.debug(
                     f"Failed to backup forecast with error {ee.args}. Raising original error."
                 )
-            raise ee
+                raise ee
         else:
             raise e
 
 
-def verify(spec: Dict, **kwargs: Dict) -> bool:
+def verify(spec: Dict) -> bool:
     """Verifies the anomaly detection operator config."""
     operator = AnomalyOperatorConfig.from_dict(spec)
     msg_header = (
@@ -83,7 +82,7 @@ def main(raw_args: List[str]):
             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:
+        except Exception:
             yaml_string = operator_spec_str
 
     operator_config = AnomalyOperatorConfig.from_yaml(

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

@@ -16,6 +16,14 @@ class SupportedModels(str, metaclass=ExtendedEnumMeta):
     Auto = "auto"
     # TODS = "tods"
 
+class NonTimeADSupportedModels(str, metaclass=ExtendedEnumMeta):
+    """Supported non time-based anomaly detection models."""
+
+    OneClassSVM = "oneclasssvm"
+    IsolationForest = "isolationforest"
+    # TODO : Add DBScan
+    # DBScan = "dbscan"
+    
 
 class TODSSubModels(str, metaclass=ExtendedEnumMeta):
     """Supported TODS sub models."""

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

@@ -84,8 +84,10 @@ class AnomalyOutput:
         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:
+        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):
@@ -93,8 +95,10 @@ class AnomalyOutput:
         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:
+        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):

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

@@ -1,32 +1,33 @@
 #!/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 fsspec
-import numpy as np
 import os
-import pandas as pd
 import tempfile
 import time
 from abc import ABC, abstractmethod
-from sklearn import linear_model
 from typing import Tuple
 
+import fsspec
+import numpy as np
+import pandas as pd
+from sklearn import linear_model
+
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.opctl import logger
 from ads.opctl.operator.lowcode.anomaly.const import OutputColumns, SupportedMetrics
 from ads.opctl.operator.lowcode.anomaly.utils import _build_metrics_df, default_signer
 from ads.opctl.operator.lowcode.common.utils import (
-    human_time_friendly,
-    enable_print,
     disable_print,
+    enable_print,
+    human_time_friendly,
     write_data,
 )
-from .anomaly_dataset import AnomalyDatasets, AnomalyOutput, TestData
-from ..const import SupportedModels
+
+from ..const import NonTimeADSupportedModels, SupportedModels
 from ..operator_config import AnomalyOperatorConfig, AnomalyOperatorSpec
+from .anomaly_dataset import AnomalyDatasets, AnomalyOutput, TestData
 
 
 class AnomalyOperatorBaseModel(ABC):
@@ -53,15 +54,18 @@ class AnomalyOperatorBaseModel(ABC):
 
     def generate_report(self):
         """Generates the report."""
-        import report_creator as rc
         import matplotlib.pyplot as plt
+        import report_creator as rc
 
         start_time = time.time()
         # fallback using sklearn oneclasssvm when the sub model _build_model fails
         try:
             anomaly_output = self._build_model()
         except Exception as e:
-            anomaly_output = self._fallback_build_model()
+            logger.warn(f"Found exception: {e}")
+            if self.spec.datetime_column:
+                anomaly_output = self._fallback_build_model()
+            raise e
 
         elapsed_time = time.time() - start_time
 
@@ -79,7 +83,9 @@ class AnomalyOperatorBaseModel(ABC):
             for col, df in self.datasets.full_data_dict.items()
         ]
         data_table = rc.Select(blocks=table_blocks)
-        date_column = self.spec.datetime_column.name
+        date_column = (
+            self.spec.datetime_column.name if self.spec.datetime_column else "index"
+        )
 
         blocks = []
         for target, df in self.datasets.full_data_dict.items():
@@ -95,7 +101,7 @@ class AnomalyOperatorBaseModel(ABC):
                 ax.grid()
                 ax.plot(time_col, y, color="black")
                 for i, index in enumerate(anomaly_col):
-                    if anomaly_col[i] == 1:
+                    if index == 1:
                         ax.scatter(time_col[i], y[i], color="red", marker="o")
                 plt.xlabel(date_column)
                 plt.ylabel(col)
@@ -114,7 +120,7 @@ class AnomalyOperatorBaseModel(ABC):
                 rc.Text(f"You selected the **`{self.spec.model}`** model."),
                 rc.Text(
                     "Based on your dataset, you could have also selected "
-                    f"any of the models: `{'`, `'.join(SupportedModels.keys())}`."
+                    f"any of the models: `{'`, `'.join(SupportedModels.keys() if self.spec.datetime_column else NonTimeADSupportedModels.keys())}`."
                 ),
                 rc.Metric(
                     heading="Analysis was completed in ",
@@ -170,7 +176,9 @@ class AnomalyOperatorBaseModel(ABC):
 
         for cat in anomaly_output.list_categories():
             output = anomaly_output.category_map[cat][0]
-            date_col = self.spec.datetime_column.name
+            date_col = (
+                self.spec.datetime_column.name if self.spec.datetime_column else "index"
+            )
 
             test_data_i = test_data.get_data_for_series(cat)
 
@@ -247,7 +255,7 @@ class AnomalyOperatorBaseModel(ABC):
         if ObjectStorageDetails.is_oci_path(unique_output_dir):
             storage_options = default_signer()
         else:
-            storage_options = dict()
+            storage_options = {}
 
         # report-creator html report
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -301,12 +309,11 @@ class AnomalyOperatorBaseModel(ABC):
         Fallback method for the sub model _build_model method.
         """
         logger.warn(
-            "The build_model method has failed for the model: {}. "
-            "A fallback model will be built.".format(self.spec.model)
+            f"The build_model method has failed for the model: {self.spec.model}. "
+            "A fallback model will be built."
         )
 
         date_column = self.spec.datetime_column.name
-        dataset = self.datasets
 
         anomaly_output = AnomalyOutput(date_column=date_column)
 
@@ -320,7 +327,9 @@ class AnomalyOperatorBaseModel(ABC):
             y_pred = np.vectorize(self.outlier_map.get)(
                 est.predict(df[self.spec.target_column].fillna(0).values.reshape(-1, 1))
             )
-            scores = est.score_samples(df[self.spec.target_column].fillna(0).values.reshape(-1, 1))
+            scores = est.score_samples(
+                df[self.spec.target_column].fillna(0).values.reshape(-1, 1)
+            )
 
             anomaly = pd.DataFrame(
                 {date_column: df[date_column], OutputColumns.ANOMALY_COL: y_pred}

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

@@ -1,26 +1,41 @@
 #!/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 ..const import SupportedModels
+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 .automlx import AutoMLXOperatorModel
 from .autots import AutoTSOperatorModel
-from ads.opctl.operator.lowcode.anomaly.utils import select_auto_model
 
 # from .tods import TODSOperatorModel
 from .base_model import AnomalyOperatorBaseModel
-from .anomaly_dataset import AnomalyDatasets
+from .isolationforest import IsolationForestOperatorModel
+from .oneclasssvm import OneClassSVMOperatorModel
 
 
 class UnSupportedModelError(Exception):
-    def __init__(self, model_type: str):
-        super().__init__(
-            f"Model: `{model_type}` "
-            f"is not supported. Supported models: {SupportedModels.values}"
+    """Exception raised when the model is not supported.
+
+    Attributes:
+        operator_config (AnomalyOperatorConfig): The operator configuration.
+        model_type (str): The type of the unsupported model.
+    """
+
+    def __init__(self, operator_config: AnomalyOperatorConfig, model_type: str):
+        supported_models = (
+            SupportedModels.values
+            if operator_config.spec.datetime_column
+            else NonTimeADSupportedModels.values
         )
+        message = (
+            f"Model: `{model_type}` is not supported. "
+            f"Supported models: {supported_models}"
+        )
+        super().__init__(message)
 
 
 class AnomalyOperatorModelFactory:
@@ -34,6 +49,13 @@ class AnomalyOperatorModelFactory:
         SupportedModels.AutoTS: AutoTSOperatorModel,
     }
 
+    _NonTime_MAP = {
+        NonTimeADSupportedModels.OneClassSVM: OneClassSVMOperatorModel,
+        NonTimeADSupportedModels.IsolationForest: IsolationForestOperatorModel,
+        # TODO: Add DBScan model for non time based anomaly
+        # NonTimeADSupportedModels.DBScan: DBScanOperatorModel,
+    }
+
     @classmethod
     def get_model(
         cls, operator_config: AnomalyOperatorConfig, datasets: AnomalyDatasets
@@ -61,7 +83,13 @@ class AnomalyOperatorModelFactory:
         """
         model_type = operator_config.spec.model
         if model_type == "auto":
-            model_type = select_auto_model(datasets, operator_config)
-        if model_type not in cls._MAP:
-            raise UnSupportedModelError(model_type)
-        return cls._MAP[model_type](config=operator_config, datasets=datasets)
+            model_type = select_auto_model(operator_config)
+
+        model_map = (
+            cls._MAP if operator_config.spec.datetime_column else cls._NonTime_MAP
+        )
+
+        if model_type not in model_map:
+            raise UnSupportedModelError(operator_config, model_type)
+
+        return model_map[model_type](config=operator_config, datasets=datasets)

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

@@ -0,0 +1,79 @@
+#!/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 numpy as np
+import pandas as pd
+
+from ads.common.decorator.runtime_dependency import runtime_dependency
+
+from .base_model import AnomalyOperatorBaseModel
+from .anomaly_dataset import AnomalyOutput
+from ads.opctl.operator.lowcode.anomaly.const import OutputColumns
+
+
+class IsolationForestOperatorModel(AnomalyOperatorBaseModel):
+    """Class representing OneClassSVM Anomaly Detection operator model."""
+
+    @runtime_dependency(
+        module="sklearn",
+        err_msg=(
+            "Please run `pip3 install scikit-learn` to "
+            "install the required dependencies for OneClassSVM."
+        ),
+    )
+    def _build_model(self) -> AnomalyOutput:
+        from sklearn.ensemble import IsolationForest
+
+        model_kwargs = self.spec.model_kwargs
+        # map the output as per anomaly dataset class, 1: outlier, 0: inlier
+        self.outlier_map = {1: 0, -1: 1}
+
+        anomaly_output = AnomalyOutput(date_column="index")
+
+        for target, df in self.datasets.full_data_dict.items():
+            model = IsolationForest(**model_kwargs)
+            model.fit(df)
+            y_pred = np.vectorize(self.outlier_map.get)(
+                model.predict(df)
+            )
+
+            scores = model.score_samples(
+                df
+            )
+
+            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": df[index_col], OutputColumns.SCORE_COL: scores}
+            ).reset_index(drop=True)
+
+            anomaly_output.add_output(target, anomaly, score)
+
+        return anomaly_output
+
+    def _generate_report(self):
+        """Generates the report."""
+        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 Isolation Forest is an ensemble of “Isolation Trees” that “isolate” observations by recursive random partitioning"
+            " which can be represented by a tree structure. The number of splittings required to isolate a sample is lower for outliers and higher for inliers."
+        )
+
+        return (
+            model_description,
+            other_sections,
+        )