oracle-ads 2.11.17__py3-none-any.whl → 2.11.19__py3-none-any.whl

ads/opctl/conda/cmds.py

@@ -80,7 +80,7 @@ def _check_job_image_exists(gpu: bool) -> None:
 def _get_name(name: str, env_file: str) -> str:
     if not name and env_file:
         with open(env_file) as f:
-            name = yaml.safe_load(f.read()).get("name", None)
+            name = yaml.safe_load(f.read()).get("manifest").get("name", None)
     if not name:
         raise ValueError(
             "Either specify environment name in environment yaml or with `--name`."
@@ -146,7 +146,14 @@ def _create(
     if not os.path.exists(env_file):
         raise FileNotFoundError(f"Environment file {env_file} is not found.")
 
-    slug = f"{name}_v{version}".replace(" ", "").replace(".", "_").lower()
+    conda_dep = None
+    with open(env_file) as mfile:
+        conda_dep = yaml.safe_load(mfile.read())
+    # If manifest exists in the environment.yaml file, use that
+    manifest = conda_dep.get("manifest", {})
+    slug = manifest.get(
+        "slug", f"{name}_v{version}".replace(" ", "").replace(".", "_").lower()
+    )
     pack_folder_path = os.path.join(
         os.path.abspath(os.path.expanduser(conda_pack_folder)), slug
     )
@@ -171,27 +178,46 @@ def _create(
 
     os.makedirs(pack_folder_path, exist_ok=True)
 
-    manifest = _fetch_manifest_template()
-    manifest["manifest"]["name"] = name
-    manifest["manifest"]["slug"] = slug
-    manifest["manifest"]["type"] = "published"
-    manifest["manifest"]["version"] = version
-    manifest["manifest"]["arch_type"] = "GPU" if gpu else "CPU"
-
-    manifest["manifest"]["create_date"] = datetime.utcnow().strftime(
+    logger.info(
+        f"Preparing manifest. Manifest in the environment: {conda_dep.get('manifest')}"
+    )
+    manifest_template = _fetch_manifest_template()
+    if "name" not in manifest:
+        manifest_template["manifest"]["name"] = name
+    manifest_template["manifest"]["slug"] = slug
+    if "type" not in manifest:
+        logger.info("Setting manifest to published")
+        manifest_template["manifest"]["type"] = "published"
+    if "version" not in manifest:
+        manifest_template["manifest"]["version"] = version
+    manifest_template["manifest"]["arch_type"] = "GPU" if gpu else "CPU"
+
+    manifest_template["manifest"]["create_date"] = datetime.utcnow().strftime(
         "%a, %b %d, %Y, %H:%M:%S %Z UTC"
     )
-    manifest["manifest"]["manifest_version"] = "1.0"
+
+    if not "manifest_version" in manifest:
+        manifest_template["manifest"]["manifest_version"] = "1.0"
 
     logger.info(f"Creating conda environment {slug}")
-    conda_dep = None
-    with open(env_file) as mfile:
-        conda_dep = yaml.safe_load(mfile.read())
-    conda_dep["manifest"] = manifest["manifest"]
+    manifest_dict = {
+        k: manifest_template["manifest"][k]
+        for k in manifest_template["manifest"]
+        if manifest_template["manifest"][k]
+    }
+    if "manifest" in conda_dep:
+        conda_dep["manifest"].update(manifest_dict)
+    else:
+        conda_dep["manifest"] = manifest_dict
+    logger.info(f"Updated conda environment manifest: {conda_dep.get('manifest')}")
 
     if is_in_notebook_session() or NO_CONTAINER:
         command = f"conda env create --prefix {pack_folder_path} --file {os.path.abspath(os.path.expanduser(env_file))}"
-        run_command(command, shell=True)
+        proc = run_command(command, shell=True)
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"Failed to create conda environment. (exit code {proc.returncode})"
+            )
     else:
         _check_job_image_exists(gpu)
         docker_pack_folder_path = os.path.join(DEFAULT_IMAGE_HOME_DIR, slug)
@@ -200,13 +226,12 @@ def _create(
         )
 
         create_command = f"conda env create --prefix {docker_pack_folder_path} --file {docker_env_file_path}"
-            
+
         volumes = {
             pack_folder_path: {"bind": docker_pack_folder_path},
             os.path.abspath(os.path.expanduser(env_file)): {
                 "bind": docker_env_file_path
             },
-
         }
 
         if gpu:
@@ -217,26 +242,42 @@ def _create(
             if prepare_publish:
                 tmp_file = tempfile.NamedTemporaryFile(suffix=".yaml")
                 # Save the manifest in the temp file that can be mounted inside the container so that archiving will work
-                with open(tmp_file.name, 'w') as f:
-                    yaml.safe_dump(conda_dep, f)      
+                with open(tmp_file.name, "w") as f:
+                    yaml.safe_dump(conda_dep, f)
 
-                pack_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pack.py")
+                pack_script = os.path.join(
+                    os.path.dirname(os.path.abspath(__file__)), "pack.py"
+                )
                 pack_command = f"python {os.path.join(DEFAULT_IMAGE_HOME_DIR, 'pack.py')} --conda-path {docker_pack_folder_path} --manifest-location {os.path.join(DEFAULT_IMAGE_HOME_DIR, 'manifest.yaml')}"
 
                 # add pack script and manifest file to the mount so that archive can be created in the same container run
                 condapack_script = {
-                    pack_script: {"bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "pack.py")},
-                    tmp_file.name: {"bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "manifest.yaml")}
+                    pack_script: {
+                        "bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "pack.py")
+                    },
+                    tmp_file.name: {
+                        "bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "manifest.yaml")
+                    },
                 }
-                volumes = {**volumes, **condapack_script} # | not supported in python 3.8
+                volumes = {
+                    **volumes,
+                    **condapack_script,
+                }  # | not supported in python 3.8
 
                 run_container(
-                    image=image, bind_volumes=volumes, entrypoint="/bin/bash -c ", env_vars={}, command=f" '{create_command} && {pack_command}'"
+                    image=image,
+                    bind_volumes=volumes,
+                    entrypoint="/bin/bash -c ",
+                    env_vars={},
+                    command=f" '{create_command} && {pack_command}'",
                 )
             else:
                 run_container(
-                    image=image, bind_volumes=volumes, env_vars={}, command=create_command
-                )                
+                    image=image,
+                    bind_volumes=volumes,
+                    env_vars={},
+                    command=create_command,
+                )
         except Exception:
             if os.path.exists(pack_folder_path):
                 shutil.rmtree(pack_folder_path)
@@ -507,9 +548,11 @@ def publish(**kwargs) -> None:
             conda_pack_folder=exec_config["conda_pack_folder"],
             gpu=exec_config.get("gpu", False),
             overwrite=exec_config["overwrite"],
-            prepare_publish=True
+            prepare_publish=True,
+        )
+        skip_archive = (
+            True  # The conda pack archive is already created during create process.
         )
-        skip_archive = True # The conda pack archive is already created during create process.
     else:
         slug = exec_config.get("slug")
     if not slug:
@@ -526,10 +569,10 @@ def publish(**kwargs) -> None:
         oci_profile=exec_config.get("oci_profile"),
         overwrite=exec_config["overwrite"],
         auth_type=exec_config["auth"],
-        skip_archive=skip_archive
+        skip_archive=skip_archive,
     )
 
-    
+
 def _publish(
     conda_slug: str,
     conda_uri_prefix: str,
@@ -538,7 +581,7 @@ def _publish(
     oci_profile: str,
     overwrite: bool,
     auth_type: str,
-    skip_archive: bool = False
+    skip_archive: bool = False,
 ) -> None:
     """Publish a local conda pack to object storage location
 
@@ -616,8 +659,16 @@ def _publish(
     pack_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pack.py")
     if not skip_archive:
         if is_in_notebook_session() or NO_CONTAINER:
+            # Set the CONDA_PUBLISH_TYPE environment variable so that the `type` attribute inside the manifest is not changed
+            publish_type = os.environ.get("CONDA_PUBLISH_TYPE")
             command = f"python {pack_script} --conda-path {pack_folder_path}"
-            run_command(command, shell=True)
+            if publish_type:
+                command = f"CONDA_PUBLISH_TYPE={publish_type} {command}"
+            proc = run_command(command, shell=True)
+            if proc.returncode != 0:
+                raise RuntimeError(
+                    f"Failed to archive the conda environment. (exit code {proc.returncode})"
+                )
         else:
             volumes = {
                 pack_folder_path: {
@@ -641,7 +692,9 @@ def _publish(
     NOT_ALLOWED_CHARS = "@#$%^&*/"
 
     if any(chr in conda_slug for chr in NOT_ALLOWED_CHARS):
-        raise ValueError(f"Invalid conda_slug. Found {NOT_ALLOWED_CHARS} in slug name. Please use a different slug name.")
+        raise ValueError(
+            f"Invalid conda_slug. Found {NOT_ALLOWED_CHARS} in slug name. Please use a different slug name."
+        )
     pack_file = os.path.join(pack_folder_path, f"{conda_slug}.tar.gz")
     if not os.path.exists(pack_file):
         raise RuntimeError(f"Pack {pack_file} was not created.")
@@ -664,14 +717,19 @@ def _publish(
         str(manifest["version"]),
         publish_slug,
     )
-    manifest["pack_path"] = os.path.join(
-        prefix,
-        manifest.get("arch_type", "CPU").lower(),
-        manifest["name"],
-        str(manifest["version"]),
-        publish_slug,
-    )
-    manifest["pack_uri"] = pack_uri
+    if os.environ.get("CONDA_PUBLISH_TYPE") != "service":
+        # Set these values only for published conda pack
+        manifest["pack_path"] = os.path.join(
+            prefix,
+            manifest.get("arch_type", "CPU").lower(),
+            manifest["name"],
+            str(manifest["version"]),
+            publish_slug,
+        )
+        manifest["pack_uri"] = pack_uri
+    else:
+        manifest["type"] = "published"
+
     with open(manifest_location, "w") as f:
         yaml.safe_dump(env, f)
     if pack_size > 100:

ads/opctl/conda/pack.py

@@ -20,7 +20,6 @@ import argparse
 
 
 def main(pack_folder_path, manifest_file=None):
-    slug = os.path.basename(pack_folder_path)
     manifest_path = (
         manifest_file or glob.glob(os.path.join(pack_folder_path, "*_manifest.yaml"))[0]
     )
@@ -47,7 +46,9 @@ def main(pack_folder_path, manifest_file=None):
             raise e
 
         manifest = env["manifest"]
-        manifest["type"] = "published"
+        slug = manifest.get("slug", os.path.basename(pack_folder_path))
+        if os.environ.get("CONDA_PUBLISH_TYPE") != "service":
+            manifest["type"] = "published"
         new_env_info["manifest"] = manifest
         with open(manifest_path, "w") as f:
             yaml.safe_dump(new_env_info, f)

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

@@ -21,6 +21,7 @@ class NonTimeADSupportedModels(str, metaclass=ExtendedEnumMeta):
 
     OneClassSVM = "oneclasssvm"
     IsolationForest = "isolationforest"
+    RandomCutForest = "randomcutforest"
     # TODO : Add DBScan
     # DBScan = "dbscan"
     

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

@@ -16,7 +16,11 @@ 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, SUBSAMPLE_THRESHOLD
+from ads.opctl.operator.lowcode.anomaly.const import (
+    SUBSAMPLE_THRESHOLD,
+    OutputColumns,
+    SupportedMetrics,
+)
 from ads.opctl.operator.lowcode.anomaly.utils import _build_metrics_df, default_signer
 from ads.opctl.operator.lowcode.common.utils import (
     disable_print,
@@ -55,6 +59,7 @@ class AnomalyOperatorBaseModel(ABC):
     def generate_report(self):
         """Generates the report."""
         import matplotlib.pyplot as plt
+        plt.rcParams.update({'figure.max_open_warning': 0})
         import report_creator as rc
 
         start_time = time.time()
@@ -87,43 +92,59 @@ class AnomalyOperatorBaseModel(ABC):
             self.spec.datetime_column.name if self.spec.datetime_column else "index"
         )
 
+        (
+            model_description,
+            other_sections,
+        ) = self._generate_report()
+
         blocks = []
         for target, df in self.datasets.full_data_dict.items():
-            figure_blocks = []
-            time_col = df[date_column].reset_index(drop=True)
-            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(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))
+            if target in anomaly_output.list_categories():
+                figure_blocks = []
+                time_col = df[date_column].reset_index(drop=True)
+                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(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))
+            else:
+                figure_blocks = None
+
+            blocks.append(rc.Group(*figure_blocks, label=target)) if figure_blocks else None
         plots = rc.Select(blocks)
 
         report_sections = []
@@ -133,7 +154,7 @@ class AnomalyOperatorBaseModel(ABC):
         yaml_appendix = rc.Yaml(self.config.to_dict())
         summary = rc.Block(
             rc.Group(
-                rc.Text(f"You selected the **`{self.spec.model}`** model."),
+                rc.Text(f"You selected the **`{self.spec.model}`** model.\n{model_description.text}\n"),
                 rc.Text(
                     "Based on your dataset, you could have also selected "
                     f"any of the models: `{'`, `'.join(SupportedModels.keys() if self.spec.datetime_column else NonTimeADSupportedModels.keys())}`."

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

@@ -15,6 +15,7 @@ from .autots import AutoTSOperatorModel
 from .base_model import AnomalyOperatorBaseModel
 from .isolationforest import IsolationForestOperatorModel
 from .oneclasssvm import OneClassSVMOperatorModel
+from .randomcutforest import RandomCutForestOperatorModel
 
 
 class UnSupportedModelError(Exception):
@@ -52,6 +53,7 @@ class AnomalyOperatorModelFactory:
     _NonTime_MAP = {
         NonTimeADSupportedModels.OneClassSVM: OneClassSVMOperatorModel,
         NonTimeADSupportedModels.IsolationForest: IsolationForestOperatorModel,
+        NonTimeADSupportedModels.RandomCutForest: RandomCutForestOperatorModel,
         # TODO: Add DBScan model for non time based anomaly
         # NonTimeADSupportedModels.DBScan: DBScanOperatorModel,
     }

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

@@ -0,0 +1,116 @@
+#!/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 numpy as np
+import pandas as pd
+
+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
+
+
+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:
+        from rrcf import RCTree
+
+        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("anamoly_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.warn(f"Encountered Error: {e}. Skipping series {target}.")
+
+        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 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/schema.yaml

@@ -363,6 +363,7 @@ spec:
         - auto
         - oneclasssvm
         - isolationforest
+        - randomcutforest
       meta:
         description: "The model to be used for anomaly detection"
 

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

@@ -14,7 +14,7 @@ class SupportedModels(str, metaclass=ExtendedEnumMeta):
     Prophet = "prophet"
     Arima = "arima"
     NeuralProphet = "neuralprophet"
-    MLForecast = "mlforecast"
+    LGBForecast = "lgbforecast"
     AutoMLX = "automlx"
     AutoTS = "autots"
     Auto = "auto"

ads/opctl/operator/lowcode/forecast/model/arima.py

@@ -126,8 +126,12 @@ class ArimaOperatorModel(ForecastOperatorBaseModel):
 
             logger.debug("===========Done===========")
         except Exception as e:
-            self.errors_dict[s_id] = {"model_name": self.spec.model, "error": str(e)}
-            logger.debug(f"Encountered Error: {e}. Skipping.")
+            self.errors_dict[s_id] = {
+                "model_name": self.spec.model,
+                "error": str(e),
+                "error_trace": traceback.format_exc()}
+            logger.warn(f"Encountered Error: {e}. Skipping.")
+            logger.warn(traceback.format_exc())
 
     def _build_model(self) -> pd.DataFrame:
         full_data_dict = self.datasets.get_data_by_series()

ads/opctl/operator/lowcode/forecast/model/automlx.py

@@ -149,6 +149,9 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 if f"{target}_ci_lower" not in summary_frame:
                     summary_frame[f"{target}_ci_lower"] = np.NAN
 
+                if summary_frame[target].isna().all():
+                    raise ValueError("The forecasts are completely NaN")
+
                 self.forecast_output.populate_series_output(
                     series_id=s_id,
                     fit_val=fitted_values,
@@ -167,8 +170,10 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 self.errors_dict[s_id] = {
                     "model_name": self.spec.model,
                     "error": str(e),
+                    "error_trace": traceback.format_exc()
                 }
-                logger.debug(f"Encountered Error: {e}. Skipping.")
+                logger.warn(f"Encountered Error: {e}. Skipping.")
+                logger.warn(traceback.format_exc())
 
         logger.debug("===========Forecast Generated===========")
 

ads/opctl/operator/lowcode/forecast/model/autots.py

@@ -208,8 +208,10 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                 self.errors_dict[s_id] = {
                     "model_name": self.spec.model,
                     "error": str(e),
+                    "error_trace": traceback.format_exc()
                 }
-            logger.debug(f"Encountered Error: {e}. Skipping.")
+            logger.warn(f"Encountered Error: {e}. Skipping.")
+            logger.warn(traceback.format_exc())
 
         logger.debug("===========Done===========")
 

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

@@ -33,7 +33,7 @@ class ForecastOperatorModelFactory:
         SupportedModels.Prophet: ProphetOperatorModel,
         SupportedModels.Arima: ArimaOperatorModel,
         SupportedModels.NeuralProphet: NeuralProphetOperatorModel,
-        SupportedModels.MLForecast: MLForecastOperatorModel,
+        SupportedModels.LGBForecast: MLForecastOperatorModel,
         SupportedModels.AutoMLX: AutoMLXOperatorModel,
         SupportedModels.AutoTS: AutoTSOperatorModel
     }