oracle-ads 2.12.4__py3-none-any.whl → 2.12.6__py3-none-any.whl

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

@@ -1,29 +1,30 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*--
-import traceback
-
 # 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 traceback
 
-import pandas as pd
 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.common.utils import (
+    seconds_to_datetime,
+)
 from ads.opctl.operator.lowcode.forecast.const import (
     AUTOMLX_METRIC_MAP,
     ForecastOutputColumns,
     SupportedModels,
 )
-from ads.opctl import logger
+from ads.opctl.operator.lowcode.forecast.utils import _label_encode_dataframe
 
-from .base_model import ForecastOperatorBaseModel
 from ..operator_config import ForecastOperatorConfig
+from .base_model import ForecastOperatorBaseModel
 from .forecast_datasets import ForecastDatasets, ForecastOutput
-from ads.opctl.operator.lowcode.common.utils import (
-    seconds_to_datetime,
-    datetime_to_seconds,
-)
-from ads.opctl.operator.lowcode.forecast.utils import _label_encode_dataframe
 
+logging.getLogger("report_creator").setLevel(logging.WARNING)
 AUTOMLX_N_ALGOS_TUNED = 4
 AUTOMLX_DEFAULT_SCORE_METRIC = "neg_sym_mean_abs_percent_error"
 
@@ -47,12 +48,13 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
         )
         model_kwargs_cleaned.pop("task", None)
         time_budget = model_kwargs_cleaned.pop("time_budget", -1)
-        model_kwargs_cleaned[
-            "preprocessing"
-        ] = self.spec.preprocessing.enabled or model_kwargs_cleaned.get("preprocessing", True)
+        model_kwargs_cleaned["preprocessing"] = (
+            self.spec.preprocessing.enabled
+            or model_kwargs_cleaned.get("preprocessing", True)
+        )
         return model_kwargs_cleaned, time_budget
 
-    def preprocess(self, data, series_id=None):  # TODO: re-use self.le for explanations
+    def preprocess(self, data):  # TODO: re-use self.le for explanations
         _, df_encoded = _label_encode_dataframe(
             data,
             no_encode={self.spec.datetime_column.name, self.original_target_column},
@@ -74,9 +76,10 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
         ),
     )
     def _build_model(self) -> pd.DataFrame:
-        from automlx import init
         import logging
 
+        from automlx import Pipeline, init
+
         try:
             init(
                 engine="ray",
@@ -88,7 +91,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
 
         full_data_dict = self.datasets.get_data_by_series()
 
-        self.models = dict()
+        self.models = {}
         horizon = self.spec.horizon
         self.spec.confidence_interval_width = self.spec.confidence_interval_width or 0.8
         self.forecast_output = ForecastOutput(
@@ -101,7 +104,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
         # Clean up kwargs for pass through
         model_kwargs_cleaned, time_budget = self.set_kwargs()
 
-        for i, (s_id, df) in enumerate(full_data_dict.items()):
+        for s_id, df in full_data_dict.items():
             try:
                 logger.debug(f"Running automlx on series {s_id}")
                 model_kwargs = model_kwargs_cleaned.copy()
@@ -120,7 +123,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 if self.loaded_models is not None and s_id in self.loaded_models:
                     model = self.loaded_models[s_id]
                 else:
-                    model = automlx.Pipeline(
+                    model = Pipeline(
                         task="forecasting",
                         **model_kwargs,
                     )
@@ -170,7 +173,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 self.errors_dict[s_id] = {
                     "model_name": self.spec.model,
                     "error": str(e),
-                    "error_trace": traceback.format_exc()
+                    "error_trace": traceback.format_exc(),
                 }
                 logger.warn(f"Encountered Error: {e}. Skipping.")
                 logger.warn(traceback.format_exc())
@@ -197,15 +200,12 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
             - ds_forecast_col (pd.Series): The pd.Series object representing the forecasted column.
             - ci_col_names (List[str]): A list of column names for the confidence interval in the report.
         """
-        import report_creator as rc
-
-        """The method that needs to be implemented on the particular model level."""
-        selected_models = dict()
+        selected_models = {}
         models = self.models
         other_sections = []
 
         if len(self.models) > 0:
-            for i, (s_id, m) in enumerate(models.items()):
+            for s_id, m in models.items():
                 selected_models[s_id] = {
                     "series_id": s_id,
                     "selected_model": m.selected_model_,
@@ -352,7 +352,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
         """
         data_temp = pd.DataFrame(
             data,
-            columns=[col for col in self.dataset_cols],
+            columns=list(self.dataset_cols),
         )
 
         return self.models.get(self.series_id).forecast(

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

@@ -1,24 +1,26 @@
 #!/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 copy
+import logging
 import traceback
+
 import pandas as pd
-import numpy as np
+import report_creator as rc
 import yaml
 
+from ads.common.decorator.runtime_dependency import runtime_dependency
 from ads.opctl import logger
-from ads.opctl.operator.lowcode.common.utils import seconds_to_datetime
-from .base_model import ForecastOperatorBaseModel
+from ads.opctl.operator.lowcode.forecast.utils import _select_plot_list
+
+from ..const import ForecastOutputColumns, SupportedModels
 from ..operator_config import ForecastOperatorConfig
-from ads.common.decorator.runtime_dependency import runtime_dependency
+from .base_model import ForecastOperatorBaseModel
 from .forecast_datasets import ForecastDatasets, ForecastOutput
-from ..const import ForecastOutputColumns, SupportedModels
-from ads.opctl.operator.lowcode.forecast.utils import _select_plot_list
 
+logging.getLogger("report_creator").setLevel(logging.WARNING)
 AUTOTS_MAX_GENERATION = 10
 AUTOTS_MODELS_TO_VALIDATE = 0.15
 
@@ -43,10 +45,9 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
         """
 
         # Import necessary libraries
-        from autots import AutoTS, create_regressor
+        from autots import AutoTS
 
         self.outputs = None
-        models = dict()
         # Get the name of the datetime column
         self.forecast_output = ForecastOutput(
             confidence_interval_width=self.spec.confidence_interval_width,
@@ -208,7 +209,7 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                 self.errors_dict[s_id] = {
                     "model_name": self.spec.model,
                     "error": str(e),
-                    "error_trace": traceback.format_exc()
+                    "error_trace": traceback.format_exc(),
                 }
             logger.warn(f"Encountered Error: {e}. Skipping.")
             logger.warn(traceback.format_exc())
@@ -231,7 +232,6 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             - ds_forecast_col (pd.Index): A pandas Index containing the forecast column values.
             - ci_col_names (list): A list of column names for confidence intervals.
         """
-        import report_creator as rc
 
         all_sections = []
         if self.models:
@@ -258,18 +258,16 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
                     yaml.dump(list(self.models.best_model.T.to_dict().values())[0]),
                 )
 
-            except KeyError as ke:
-                logger.warn(
-                    f"Issue generating Model Parameters Table Section. Skipping"
-                )
+            except KeyError:
+                logger.warn("Issue generating Model Parameters Table Section. Skipping")
                 sec2 = rc.Text("Error generating model parameters.")
 
             section_2 = rc.Block(sec2_text, sec2)
 
-            all_sections = [sec_1_plots, section_2]
+            all_sections = [section_1, section_2]
 
         if self.spec.generate_explanations:
-            logger.warn(f"Explanations not yet supported for the AutoTS Module")
+            logger.warn("Explanations not yet supported for the AutoTS Module")
 
         # Model Description
         model_description = rc.Text(
@@ -305,7 +303,7 @@ class AutoTSOperatorModel(ForecastOperatorBaseModel):
             ).T
             df = pd.concat([mapes, scores])
         except Exception as e:
-            logger.debug(f"Failed to generate training metrics")
+            logger.debug("Failed to generate training metrics")
             logger.debug(f"Received Error Statement: {e}")
 
         return df

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

@@ -1,52 +1,57 @@
 #!/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 logging
 import os
-import pandas as pd
 import tempfile
 import time
 import traceback
 from abc import ABC, abstractmethod
 from typing import Tuple
 
+import fsspec
+import numpy as np
+import pandas as pd
+import report_creator as rc
+
 from ads.common.decorator.runtime_dependency import runtime_dependency
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.opctl import logger
 from ads.opctl.operator.lowcode.common.utils import (
-    human_time_friendly,
-    enable_print,
+    datetime_to_seconds,
     disable_print,
-    write_data,
+    enable_print,
+    human_time_friendly,
     merged_category_column_name,
-    datetime_to_seconds,
     seconds_to_datetime,
+    write_data,
 )
 from ads.opctl.operator.lowcode.forecast.model.forecast_datasets import TestData
 from ads.opctl.operator.lowcode.forecast.utils import (
+    _build_metrics_df,
+    _build_metrics_per_horizon,
+    _label_encode_dataframe,
     default_signer,
     evaluate_train_metrics,
-    get_forecast_plots,
     get_auto_select_plot,
-    _build_metrics_df,
-    _build_metrics_per_horizon,
+    get_forecast_plots,
     load_pkl,
     write_pkl,
-    _label_encode_dataframe,
 )
-from .forecast_datasets import ForecastDatasets
+
 from ..const import (
+    AUTO_SELECT,
     SUMMARY_METRICS_HORIZON_LIMIT,
+    SpeedAccuracyMode,
     SupportedMetrics,
     SupportedModels,
-    SpeedAccuracyMode,
-    AUTO_SELECT
 )
 from ..operator_config import ForecastOperatorConfig, ForecastOperatorSpec
+from .forecast_datasets import ForecastDatasets
+
+logging.getLogger("report_creator").setLevel(logging.WARNING)
 
 
 class ForecastOperatorBaseModel(ABC):
@@ -70,7 +75,7 @@ class ForecastOperatorBaseModel(ABC):
         self.original_target_column = self.spec.target_column
         self.dt_column_name = self.spec.datetime_column.name
 
-        self.model_parameters = dict()
+        self.model_parameters = {}
         self.loaded_models = None
 
         # these fields are populated in the _build_model() method
@@ -79,20 +84,21 @@ class ForecastOperatorBaseModel(ABC):
         # "outputs" is a list of outputs generated by the models. These should only be generated when the framework requires the original output for plotting
         self.outputs = None
         self.forecast_output = None
-        self.errors_dict = dict()
-        self.le = dict()
+        self.errors_dict = {}
+        self.le = {}
 
         self.formatted_global_explanation = None
         self.formatted_local_explanation = None
 
         self.forecast_col_name = "yhat"
-        self.perform_tuning = (self.spec.tuning != None) and (
-            self.spec.tuning.n_trials != None
+        self.perform_tuning = (self.spec.tuning is not None) and (
+            self.spec.tuning.n_trials is not None
         )
 
     def generate_report(self):
         """Generates the forecasting report."""
         import warnings
+
         from sklearn.exceptions import ConvergenceWarning
 
         with warnings.catch_warnings():
@@ -100,7 +106,6 @@ class ForecastOperatorBaseModel(ABC):
             warnings.simplefilter(action="ignore", category=UserWarning)
             warnings.simplefilter(action="ignore", category=RuntimeWarning)
             warnings.simplefilter(action="ignore", category=ConvergenceWarning)
-            import report_creator as rc
 
             # load models if given
             if self.spec.previous_output_dir is not None:
@@ -128,7 +133,7 @@ class ForecastOperatorBaseModel(ABC):
                         ) = self._test_evaluate_metrics(
                             elapsed_time=elapsed_time,
                         )
-                    except Exception as e:
+                    except Exception:
                         logger.warn("Unable to generate Test Metrics.")
                         logger.debug(f"Full Traceback: {traceback.format_exc()}")
             report_sections = []
@@ -253,25 +258,30 @@ class ForecastOperatorBaseModel(ABC):
                 backtest_report_name = "backtest_stats.csv"
                 file_path = f"{output_dir}/{backtest_report_name}"
                 if self.spec.model == AUTO_SELECT:
-                    backtest_sections.append(rc.Heading("Auto-select statistics", level=2))
+                    backtest_sections.append(
+                        rc.Heading("Auto-select statistics", level=2)
+                    )
                     if not os.path.exists(file_path):
-                        failure_msg = rc.Text("auto-select could not be executed. Please check the "
-                                              "logs for more details.")
+                        failure_msg = rc.Text(
+                            "auto-select could not be executed. Please check the "
+                            "logs for more details."
+                        )
                         backtest_sections.append(failure_msg)
                     else:
                         backtest_stats = pd.read_csv(file_path)
                         average_dict = backtest_stats.mean().to_dict()
-                        del average_dict['backtest']
+                        del average_dict["backtest"]
                         best_model = min(average_dict, key=average_dict.get)
                         backtest_text = rc.Heading("Back Testing Metrics", level=3)
                         summary_text = rc.Text(
                             f"Overall, the average scores for the models are {average_dict}, with {best_model}"
-                            f" being identified as the top-performing model during backtesting.")
+                            f" being identified as the top-performing model during backtesting."
+                        )
                         backtest_table = rc.DataTable(backtest_stats, index=True)
                         liner_plot = get_auto_select_plot(backtest_stats)
-                        backtest_sections.extend([backtest_text, backtest_table, summary_text,
-                                                                      liner_plot])
-
+                        backtest_sections.extend(
+                            [backtest_text, backtest_table, summary_text, liner_plot]
+                        )
 
                 forecast_plots = []
                 if len(self.forecast_output.list_series_ids()) > 0:
@@ -431,14 +441,13 @@ class ForecastOperatorBaseModel(ABC):
         test_metrics_df: pd.DataFrame,
     ):
         """Saves resulting reports to the given folder."""
-        import report_creator as rc
 
         unique_output_dir = self.spec.output_directory.url
 
         if ObjectStorageDetails.is_oci_path(unique_output_dir):
             storage_options = default_signer()
         else:
-            storage_options = dict()
+            storage_options = {}
 
         # report-creator html report
         if self.spec.generate_report:
@@ -580,7 +589,7 @@ class ForecastOperatorBaseModel(ABC):
                 indent=4,
             )
         else:
-            logger.info(f"All modeling completed successfully.")
+            logger.info("All modeling completed successfully.")
 
     def preprocess(self, df, series_id):
         """The method that needs to be implemented on the particular model level."""
@@ -622,8 +631,8 @@ class ForecastOperatorBaseModel(ABC):
     def _load_model(self):
         try:
             self.loaded_models = load_pkl(self.spec.previous_output_dir + "/model.pkl")
-        except:
-            logger.info("model.pkl is not present")
+        except Exception as e:
+            logger.info(f"model.pkl is not present. Error: {e}")
 
     def _save_model(self, output_dir, storage_options):
         write_pkl(
@@ -693,7 +702,7 @@ class ForecastOperatorBaseModel(ABC):
 
                 if not len(kernel_explnr_vals):
                     logger.warn(
-                        f"No explanations generated. Ensure that additional data has been provided."
+                        "No explanations generated. Ensure that additional data has been provided."
                     )
                 else:
                     self.global_explanation[s_id] = dict(

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

@@ -1,33 +1,23 @@
 #!/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/
 
-import time
 import pandas as pd
-from pandas.api.types import is_datetime64_any_dtype, is_string_dtype, is_numeric_dtype
 
-from ..operator_config import ForecastOperatorConfig
 from ads.opctl import logger
-from ..const import ForecastOutputColumns, PROPHET_INTERNAL_DATE_COL
-from ads.common.object_storage_details import ObjectStorageDetails
-from ads.opctl.operator.lowcode.common.utils import (
-    get_frequency_in_seconds,
-    get_frequency_of_datetime,
-)
 from ads.opctl.operator.lowcode.common.data import AbstractData
-from ads.opctl.operator.lowcode.forecast.utils import (
-    default_signer,
-)
 from ads.opctl.operator.lowcode.common.errors import (
-    InputDataError,
-    InvalidParameterError,
-    PermissionsError,
     DataMismatchError,
+    InvalidParameterError,
+)
+from ads.opctl.operator.lowcode.common.utils import (
+    get_frequency_in_seconds,
+    get_frequency_of_datetime,
 )
-from ..const import SupportedModels
-from abc import ABC, abstractmethod
+
+from ..const import ForecastOutputColumns, SupportedModels
+from ..operator_config import ForecastOperatorConfig
 
 
 class HistoricalData(AbstractData):
@@ -51,13 +41,12 @@ class HistoricalData(AbstractData):
         self.freq_in_secs = get_frequency_in_seconds(
             self.data.index.get_level_values(0)
         )
-        if spec.model == SupportedModels.AutoMLX:
-            if abs(self.freq_in_secs) < 3600:
-                message = (
-                    "{} requires data with a frequency of at least one hour. Please try using a different model,"
-                    " or select the 'auto' option.".format(SupportedModels.AutoMLX)
-                )
-                raise InvalidParameterError(message)
+        if spec.model == SupportedModels.AutoMLX and abs(self.freq_in_secs) < 3600:
+            message = (
+                f"{SupportedModels.AutoMLX} requires data with a frequency of at least one hour. Please try using a different model,"
+                " or select the 'auto' option."
+            )
+            raise InvalidParameterError(message)
 
 
 class AdditionalData(AbstractData):
@@ -77,11 +66,11 @@ class AdditionalData(AbstractData):
         else:
             self.name = "additional_data"
             self.data = None
-            self._data_dict = dict()
+            self._data_dict = {}
             self.create_horizon(spec, historical_data)
 
     def create_horizon(self, spec, historical_data):
-        logger.debug(f"No additional data provided. Constructing horizon.")
+        logger.debug("No additional data provided. Constructing horizon.")
         future_dates = pd.Series(
             pd.date_range(
                 start=historical_data.get_max_time(),
@@ -109,6 +98,7 @@ class AdditionalData(AbstractData):
         self.additional_regressors = []
 
     def _ingest_data(self, spec):
+        _spec = spec
         self.additional_regressors = list(self.data.columns)
         if not self.additional_regressors:
             logger.warn(
@@ -146,12 +136,11 @@ class ForecastDatasets:
         self.historical_data = HistoricalData(spec)
         self.additional_data = AdditionalData(spec, self.historical_data)
 
-        if spec.generate_explanations:
-            if spec.additional_data is None:
-                logger.warn(
-                    f"Unable to generate explanations as there is no additional data passed in. Either set generate_explanations to False, or pass in additional data."
-                )
-                spec.generate_explanations = False
+        if spec.generate_explanations and spec.additional_data is None:
+            logger.warn(
+                "Unable to generate explanations as there is no additional data passed in. Either set generate_explanations to False, or pass in additional data."
+            )
+            spec.generate_explanations = False
 
     def get_all_data_long(self, include_horizon=True):
         how = "outer" if include_horizon else "left"
@@ -182,7 +171,7 @@ class ForecastDatasets:
         )
 
     def get_data_by_series(self, include_horizon=True):
-        total_dict = dict()
+        total_dict = {}
         hist_data = self.historical_data.get_dict_by_series()
         add_data = self.additional_data.get_dict_by_series()
         how = "outer" if include_horizon else "left"
@@ -200,10 +189,10 @@ class ForecastDatasets:
         all_data = self.get_data_by_series(include_horizon=include_horizon)
         try:
             return all_data[s_id]
-        except:
+        except Exception as e:
             raise InvalidParameterError(
                 f"Unable to retrieve series id: {s_id} from data. Available series ids are: {self.list_series_ids()}"
-            )
+            ) from e
 
     def get_horizon_at_series(self, s_id):
         return self.get_data_at_series(s_id)[-self._horizon :]
@@ -234,7 +223,7 @@ class ForecastDatasets:
         if sorted:
             try:
                 series_ids.sort()
-            except:
+            except Exception:
                 pass
         return series_ids
 
@@ -269,7 +258,7 @@ class ForecastOutput:
         target_column: str the name of the original target column
         dt_column: the name of the original datetime column
         """
-        self.series_id_map = dict()
+        self.series_id_map = {}
         self._set_ci_column_names(confidence_interval_width)
         self.horizon = horizon
         self.target_column_name = target_column
@@ -281,7 +270,7 @@ class ForecastOutput:
         forecast: pd.DataFrame,
         overwrite: bool = False,
     ):
-        if not overwrite and series_id in self.series_id_map.keys():
+        if not overwrite and series_id in self.series_id_map:
             raise ValueError(
                 f"Attempting to update ForecastOutput for series_id {series_id} when this already exists. Set overwrite to True."
             )
@@ -321,15 +310,15 @@ class ForecastOutput:
         """
         try:
             output_i = self.series_id_map[series_id]
-        except KeyError:
+        except KeyError as e:
             raise ValueError(
                 f"Attempting to update output for series: {series_id}, however no series output has been initialized."
-            )
+            ) from e
 
         if (output_i.shape[0] - self.horizon) == len(fit_val):
-            output_i["fitted_value"].iloc[
-                : -self.horizon
-            ] = fit_val  # Note: may need to do len(output_i) - (len(fit_val) + horizon) : -horizon
+            output_i["fitted_value"].iloc[: -self.horizon] = (
+                fit_val  # Note: may need to do len(output_i) - (len(fit_val) + horizon) : -horizon
+            )
         elif (output_i.shape[0] - self.horizon) > len(fit_val):
             logger.debug(
                 f"Fitted Values were only generated on a subset ({len(fit_val)}/{(output_i.shape[0] - self.horizon)}) of the data for Series: {series_id}."
@@ -378,7 +367,7 @@ class ForecastOutput:
     def get_forecast(self, series_id):
         try:
             return self.series_id_map[series_id]
-        except KeyError as ke:
+        except KeyError:
             logger.debug(
                 f"No Forecast found for series_id: {series_id}. Returning empty DataFrame."
             )
@@ -389,7 +378,7 @@ class ForecastOutput:
         if sorted:
             try:
                 series_ids.sort()
-            except:
+            except Exception:
                 pass
         return series_ids
 

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

@@ -2,6 +2,7 @@
 
 # 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 logging
 import traceback
 
 import pandas as pd
@@ -192,6 +193,8 @@ class MLForecastOperatorModel(ForecastOperatorBaseModel):
         import report_creator as rc
         from utilsforecast.plotting import plot_series
 
+        logging.getLogger("report_creator").setLevel(logging.WARNING)
+
         # Section 1: Forecast Overview
         sec1_text = rc.Block(
             rc.Heading("Forecast Overview", level=2),