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

ads/jobs/builders/runtimes/container_runtime.py

@@ -3,9 +3,12 @@
 
 # Copyright (c) 2021, 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
 from typing import Union
 from ads.jobs.builders.runtimes.base import MultiNodeRuntime
 
+logger = logging.getLogger(__name__)
+
 
 class ContainerRuntime(MultiNodeRuntime):
     """Represents a container job runtime
@@ -13,18 +16,23 @@ class ContainerRuntime(MultiNodeRuntime):
     To define container runtime:
 
     >>> ContainerRuntime()
-    >>> .with_image("iad.ocir.io/<your_tenancy>/<your_image>")
+    >>> .with_image("iad.ocir.io/<your_tenancy>/<your_image>:<tag>")
     >>> .with_cmd("sleep 5 && echo Hello World")
     >>> .with_entrypoint(["/bin/sh", "-c"])
+    >>> .with_image_digest("<image_digest>")
+    >>> .with_image_signature_id("<image_signature_id>")
     >>> .with_environment_variable(MY_ENV="MY_VALUE")
 
-    Alternatively, you can define the ``entrypoint`` and ``cmd`` along with the image.
+    Alternatively, you can define the ``entrypoint``, ``cmd``,
+    ``image_digest``and ``image_signature_id`` along with the image.
 
     >>> ContainerRuntime()
     >>> .with_image(
-    >>>     "iad.ocir.io/<your_tenancy>/<your_image>",
+    >>>     "iad.ocir.io/<your_tenancy>/<your_image>:<tag>",
     >>>     entrypoint=["/bin/sh", "-c"],
     >>>     cmd="sleep 5 && echo Hello World",
+    >>>     image_digest="<image_digest>",
+    >>>     image_signature_id="<image_signature_id>",
     >>> )
     >>> .with_environment_variable(MY_ENV="MY_VALUE")
 
@@ -46,20 +54,34 @@ class ContainerRuntime(MultiNodeRuntime):
     CONST_IMAGE = "image"
     CONST_ENTRYPOINT = "entrypoint"
     CONST_CMD = "cmd"
+    CONST_IMAGE_DIGEST = "imageDigest"
+    CONST_IMAGE_SIGNATURE_ID = "imageSignatureId"
     attribute_map = {
         CONST_IMAGE: CONST_IMAGE,
         CONST_ENTRYPOINT: CONST_ENTRYPOINT,
         CONST_CMD: CONST_CMD,
+        CONST_IMAGE_DIGEST: "image_digest",
+        CONST_IMAGE_SIGNATURE_ID: "image_signature_id",
     }
     attribute_map.update(MultiNodeRuntime.attribute_map)
 
+    @property
+    def job_env_type(self) -> str:
+        """The container type"""
+        return "OCIR_CONTAINER"
+
     @property
     def image(self) -> str:
         """The container image"""
         return self.get_spec(self.CONST_IMAGE)
 
     def with_image(
-        self, image: str, entrypoint: Union[str, list, None] = None, cmd: str = None
+        self,
+        image: str,
+        entrypoint: Union[str, list, None] = None, 
+        cmd: str = None,
+        image_digest: str = None,
+        image_signature_id: str = None,
     ) -> "ContainerRuntime":
         """Specify the image for the container job.
 
@@ -71,16 +93,73 @@ class ContainerRuntime(MultiNodeRuntime):
             Entrypoint for the job, by default None (the entrypoint defined in the image will be used).
         cmd : str, optional
             Command for the job, by default None.
+        image_digest: str, optional
+            The image digest, by default None.
+        image_signature_id: str, optional
+            The image signature id, by default None.
 
         Returns
         -------
         ContainerRuntime
             The runtime instance.
         """
+        if not isinstance(image, str):
+            raise ValueError(
+                "Custom image must be provided as a string."
+            )
+        if image.find(":") < 0:
+            logger.warning(
+                "Tag is required for custom image. Accepted format: iad.ocir.io/<tenancy>/<image>:<tag>."
+            )
         self.with_entrypoint(entrypoint)
         self.set_spec(self.CONST_CMD, cmd)
+        self.with_image_digest(image_digest)
+        self.with_image_signature_id(image_signature_id)
         return self.set_spec(self.CONST_IMAGE, image)
 
+    @property
+    def image_digest(self) -> str:
+        """The container image digest."""
+        return self.get_spec(self.CONST_IMAGE_DIGEST)
+    
+    def with_image_digest(self, image_digest: str) -> "ContainerRuntime":
+        """Sets the digest of custom image.
+
+        Parameters
+        ----------
+        image_digest: str
+            The image digest.
+
+        Returns
+        -------
+        ContainerRuntime
+            The runtime instance.
+        """
+        return self.set_spec(self.CONST_IMAGE_DIGEST, image_digest)
+    
+    @property
+    def image_signature_id(self) -> str:
+        """The container image signature id."""
+        return self.get_spec(self.CONST_IMAGE_SIGNATURE_ID)
+    
+    def with_image_signature_id(self, image_signature_id: str) -> "ContainerRuntime":
+        """Sets the signature id of custom image.
+
+        Parameters
+        ----------
+        image_signature_id: str
+            The image signature id.
+
+        Returns
+        -------
+        ContainerRuntime
+            The runtime instance.
+        """
+        return self.set_spec(
+            self.CONST_IMAGE_SIGNATURE_ID,
+            image_signature_id
+        )
+
     @property
     def entrypoint(self) -> str:
         """Entrypoint of the container job"""

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."""
@@ -86,3 +94,4 @@ class OutputColumns(str, metaclass=ExtendedEnumMeta):
 
 
 TODS_DEFAULT_MODEL = "ocsvm"
+SUBSAMPLE_THRESHOLD = 1000

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.const import OutputColumns, SupportedMetrics, SUBSAMPLE_THRESHOLD
 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
 
@@ -75,11 +79,13 @@ class AnomalyOperatorBaseModel(ABC):
                 anomaly_output, test_data, elapsed_time
             )
         table_blocks = [
-            rc.DataTable(df, label=col, index=True)
+            rc.DataTable(df.head(SUBSAMPLE_THRESHOLD) if self.spec.subsample_report_data and len(df) > SUBSAMPLE_THRESHOLD else df, label=col, index=True)
             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():
@@ -88,20 +94,36 @@ class AnomalyOperatorBaseModel(ABC):
             anomaly_col = anomaly_output.get_anomalies_by_cat(category=target)[
                 OutputColumns.ANOMALY_COL
             ]
+            anomaly_indices = [i for i, index in enumerate(anomaly_col) if index == 1]
+            downsampled_time_col = time_col
+            selected_indices = list(range(len(time_col)))
+            if self.spec.subsample_report_data:
+                non_anomaly_indices = [i for i in range(len(time_col)) if i not in anomaly_indices]
+                # Downsample non-anomalous data if it exceeds the threshold (1000)
+                if len(non_anomaly_indices) > SUBSAMPLE_THRESHOLD:
+                    downsampled_non_anomaly_indices = non_anomaly_indices[::len(non_anomaly_indices)//SUBSAMPLE_THRESHOLD]
+                    selected_indices = anomaly_indices + downsampled_non_anomaly_indices
+                    selected_indices.sort()
+                downsampled_time_col = time_col[selected_indices]
+
             columns = set(df.columns).difference({date_column})
             for col in columns:
                 y = df[col].reset_index(drop=True)
+
+                downsampled_y = y[selected_indices]
+
                 fig, ax = plt.subplots(figsize=(8, 3), layout="constrained")
                 ax.grid()
-                ax.plot(time_col, y, color="black")
-                for i, index in enumerate(anomaly_col):
-                    if anomaly_col[i] == 1:
-                        ax.scatter(time_col[i], y[i], color="red", marker="o")
+                ax.plot(downsampled_time_col, downsampled_y, color="black")
+                # Plot anomalies
+                for i in anomaly_indices:
+                    ax.scatter(time_col[i], y[i], color="red", marker="o")
                 plt.xlabel(date_column)
                 plt.ylabel(col)
                 plt.title(f"`{col}` with reference to anomalies")
                 figure_blocks.append(rc.Widget(ax))
-            blocks.append(rc.Group(*figure_blocks, label=target))
+
+        blocks.append(rc.Group(*figure_blocks, label=target))
         plots = rc.Select(blocks)
 
         report_sections = []
@@ -114,7 +136,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 +192,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 +271,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 +325,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 +343,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,
+        )