oracle-ads 2.11.9__py3-none-any.whl → 2.11.10__py3-none-any.whl

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

@@ -0,0 +1,234 @@
+#!/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 pandas as pd
+import numpy as np
+
+from ads.opctl import logger
+from ads.common.decorator import runtime_dependency
+from ads.opctl.operator.lowcode.forecast.utils import _select_plot_list
+from .base_model import ForecastOperatorBaseModel
+from .forecast_datasets import ForecastDatasets, ForecastOutput
+from ..operator_config import ForecastOperatorConfig
+from ..const import ForecastOutputColumns, SupportedModels
+
+
+class MLForecastOperatorModel(ForecastOperatorBaseModel):
+    """Class representing MLForecast operator model."""
+
+    def __init__(self, config: ForecastOperatorConfig, datasets: ForecastDatasets):
+        super().__init__(config=config, datasets=datasets)
+        self.global_explanation = {}
+        self.local_explanation = {}
+        self.formatted_global_explanation = None
+        self.formatted_local_explanation = None
+        self.date_col = config.spec.datetime_column.name
+
+    def set_kwargs(self):
+        """
+        Returns the model parameters.
+        """
+        model_kwargs = self.spec.model_kwargs
+
+        uppper_quantile = round(0.5 + self.spec.confidence_interval_width / 2, 2)
+        lower_quantile = round(0.5 - self.spec.confidence_interval_width / 2, 2)
+
+        model_kwargs["lower_quantile"] = lower_quantile
+        model_kwargs["uppper_quantile"] = uppper_quantile
+        return model_kwargs
+
+    def preprocess(self, df, series_id):
+        pass
+
+    @runtime_dependency(
+        module="mlforecast",
+        err_msg="MLForecast is not installed, please install it with 'pip install mlforecast'",
+    )
+    @runtime_dependency(
+        module="lightgbm",
+        err_msg="lightgbm is not installed, please install it with 'pip install lightgbm'",
+    )
+    def _train_model(self, data_train, data_test, model_kwargs):
+        try:
+            import lightgbm as lgb
+            from mlforecast import MLForecast
+            from mlforecast.lag_transforms import ExpandingMean, RollingMean
+            from mlforecast.target_transforms import Differences
+
+            lgb_params = {
+                "verbosity": -1,
+                "num_leaves": 512,
+            }
+
+            fcst = MLForecast(
+                models={
+                    "forecast": lgb.LGBMRegressor(**lgb_params),
+                    # "p" + str(int(model_kwargs["uppper_quantile"] * 100))
+                    "upper": lgb.LGBMRegressor(
+                        **lgb_params,
+                        objective="quantile",
+                        alpha=model_kwargs["uppper_quantile"],
+                    ),
+                    # "p" + str(int(model_kwargs["lower_quantile"] * 100))
+                    "lower": lgb.LGBMRegressor(
+                        **lgb_params,
+                        objective="quantile",
+                        alpha=model_kwargs["lower_quantile"],
+                    ),
+                },
+                freq=pd.infer_freq(data_train[self.date_col].drop_duplicates())
+                or pd.infer_freq(data_train[self.date_col].drop_duplicates()[-5:]),
+                target_transforms=[Differences([12])],
+                lags=model_kwargs.get(
+                    "lags",
+                    (
+                        [1, 6, 12]
+                        if len(self.datasets.get_additional_data_column_names()) > 0
+                        else []
+                    ),
+                ),
+                lag_transforms=(
+                    {
+                        1: [ExpandingMean()],
+                        12: [RollingMean(window_size=24)],
+                    }
+                    if len(self.datasets.get_additional_data_column_names()) > 0
+                    else {}
+                ),
+                # date_features=[hour_index],
+            )
+
+            num_models = model_kwargs.get("recursive_models", False)
+
+            self.model_columns = [
+                ForecastOutputColumns.SERIES
+            ] + data_train.select_dtypes(exclude=["object"]).columns.to_list()
+            fcst.fit(
+                data_train[self.model_columns],
+                static_features=model_kwargs.get("static_features", []),
+                id_col=ForecastOutputColumns.SERIES,
+                time_col=self.date_col,
+                target_col=self.spec.target_column,
+                fitted=True,
+                max_horizon=None if num_models is False else self.spec.horizon,
+            )
+
+            self.outputs = fcst.predict(
+                h=self.spec.horizon,
+                X_df=pd.concat(
+                    [
+                        data_test[self.model_columns],
+                        fcst.get_missing_future(
+                            h=self.spec.horizon, X_df=data_test[self.model_columns]
+                        ),
+                    ],
+                    axis=0,
+                    ignore_index=True,
+                ).fillna(0),
+            )
+            self.fitted_values = fcst.forecast_fitted_values()
+            for s_id in self.datasets.list_series_ids():
+                self.forecast_output.init_series_output(
+                    series_id=s_id,
+                    data_at_series=self.datasets.get_data_at_series(s_id),
+                )
+
+                self.forecast_output.populate_series_output(
+                    series_id=s_id,
+                    fit_val=self.fitted_values[
+                        self.fitted_values[ForecastOutputColumns.SERIES] == s_id
+                    ].forecast.values,
+                    forecast_val=self.outputs[
+                        self.outputs[ForecastOutputColumns.SERIES] == s_id
+                    ].forecast.values,
+                    upper_bound=self.outputs[
+                        self.outputs[ForecastOutputColumns.SERIES] == s_id
+                    ].upper.values,
+                    lower_bound=self.outputs[
+                        self.outputs[ForecastOutputColumns.SERIES] == s_id
+                    ].lower.values,
+                )
+
+                self.model_parameters[s_id] = {
+                    "framework": SupportedModels.MLForecast,
+                    **lgb_params,
+                }
+
+            logger.debug("===========Done===========")
+
+        except Exception as e:
+            self.errors_dict[self.spec.model] = {
+                "model_name": self.spec.model,
+                "error": str(e),
+            }
+            logger.debug(f"Encountered Error: {e}. Skipping.")
+
+    def _build_model(self) -> pd.DataFrame:
+        data_train = self.datasets.get_all_data_long(include_horizon=False)
+        data_test = self.datasets.get_all_data_long_forecast_horizon()
+        self.models = dict()
+        model_kwargs = self.set_kwargs()
+        self.forecast_output = ForecastOutput(
+            confidence_interval_width=self.spec.confidence_interval_width,
+            horizon=self.spec.horizon,
+            target_column=self.original_target_column,
+            dt_column=self.date_col,
+        )
+        self._train_model(data_train, data_test, model_kwargs)
+        return self.forecast_output.get_forecast_long()
+
+    def _generate_report(self):
+        """
+        Generates the report for the model
+        """
+        import report_creator as rc
+        from utilsforecast.plotting import plot_series
+
+        # Section 1: Forecast Overview
+        sec1_text = rc.Block(
+            rc.Heading("Forecast Overview", level=2),
+            rc.Text(
+                "These plots show your forecast in the context of historical data."
+            ),
+        )
+        sec_1 = _select_plot_list(
+            lambda s_id: plot_series(
+                self.datasets.get_all_data_long(include_horizon=False),
+                pd.concat(
+                    [self.fitted_values, self.outputs], axis=0, ignore_index=True
+                ),
+                id_col=ForecastOutputColumns.SERIES,
+                time_col=self.spec.datetime_column.name,
+                target_col=self.original_target_column,
+                seed=42,
+                ids=[s_id],
+            ),
+            self.datasets.list_series_ids(),
+        )
+
+        # Section 2: MlForecast Model Parameters
+        sec2_text = rc.Block(
+            rc.Heading("MlForecast Model Parameters", level=2),
+            rc.Text("These are the parameters used for the MlForecast model."),
+        )
+
+        blocks = [
+            rc.Html(
+                str(s_id[1]),
+                label=s_id[0],
+            )
+            for _, s_id in enumerate(self.model_parameters.items())
+        ]
+        sec_2 = rc.Select(blocks=blocks)
+
+        all_sections = [sec1_text, sec_1, sec2_text, sec_2]
+        model_description = rc.Text(
+            "mlforecast is a framework to perform time series forecasting using machine learning models"
+            "with the option to scale to massive amounts of data using remote clusters."
+            "Fastest implementations of feature engineering for time series forecasting in Python."
+            "Support for exogenous variables and static covariates."
+        )
+
+        return model_description, all_sections

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

@@ -75,6 +75,8 @@ def _fit_model(data, params, additional_regressors, select_metric):
         m = m.add_future_regressor(name=add_reg)
     m.fit(df=data)
     accepted_regressors_config = m.config_regressors or dict()
+    if hasattr(accepted_regressors_config, "regressors"):
+        accepted_regressors_config = accepted_regressors_config.regressors or dict()
 
     enable_print()
     return m, list(accepted_regressors_config.keys())
@@ -122,7 +124,13 @@ class NeuralProphetOperatorModel(ForecastOperatorBaseModel):
 
             if self.loaded_models is not None and s_id in self.loaded_models:
                 model = self.loaded_models[s_id]
-                accepted_regressors_config = model.config_regressors or dict()
+                accepted_regressors_config = (
+                    model.config_regressors.regressors or dict()
+                )
+                if hasattr(accepted_regressors_config, "regressors"):
+                    accepted_regressors_config = (
+                        accepted_regressors_config.regressors or dict()
+                    )
                 self.accepted_regressors[s_id] = list(accepted_regressors_config.keys())
                 if self.loaded_trainers is not None and s_id in self.loaded_trainers:
                     model.trainer = self.loaded_trainers[s_id]

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

@@ -131,6 +131,7 @@ class ProphetOperatorModel(ForecastOperatorBaseModel):
                 "model_name": self.spec.model,
                 "error": str(e),
             }
+            logger.debug(f"Encountered Error: {e}. Skipping.")
 
     def _build_model(self) -> pd.DataFrame:
         full_data_dict = self.datasets.get_data_by_series()

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

@@ -0,0 +1,147 @@
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+
+from ads.opctl import logger
+from ads.opctl.operator.lowcode.common.const import DataColumns
+from .model.forecast_datasets import ForecastDatasets
+from .operator_config import ForecastOperatorConfig
+
+
+class ModelEvaluator:
+    """
+    A class used to evaluate and determine the best model or framework from a given set of candidates.
+
+    This class is responsible for comparing different models or frameworks based on specified evaluation
+    metrics and returning the best-performing option.
+    """
+    def __init__(self, models, k=5, subsample_ratio=0.20):
+        """
+        Initializes the ModelEvaluator with a list of models, number of backtests and subsample ratio.
+
+        Properties:
+        ----------
+        models (list): The list of model to be evaluated.
+        k (int): The number of times each model is backtested to verify its performance.
+        subsample_ratio (float): The proportion of the data used in the evaluation process.
+        """
+        self.models = models
+        self.k = k
+        self.subsample_ratio = subsample_ratio
+        self.minimum_sample_count = 5
+
+    def generate_cutoffs(self, unique_dates, horizon):
+        sorted_dates = np.sort(unique_dates)
+        train_window_size = [len(sorted_dates) - (i + 1) * horizon for i in range(self.k)]
+        valid_train_window_size = [ws for ws in train_window_size if ws >= horizon * 3]
+        if len(valid_train_window_size) < self.k:
+            logger.warn(f"Only {valid_train_window_size} backtests can be created")
+        cut_offs = sorted_dates[-horizon - 1:-horizon * (self.k + 1):-horizon][:len(valid_train_window_size)]
+        return cut_offs
+
+    def generate_k_fold_data(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
+        date_col = operator_config.spec.datetime_column.name
+        horizon = operator_config.spec.horizon
+        historical_data = datasets.historical_data.data.reset_index()
+        series_col = DataColumns.Series
+        group_counts = historical_data[series_col].value_counts()
+
+        sample_count = max(self.minimum_sample_count, int(len(group_counts) * self.subsample_ratio))
+        sampled_groups = group_counts.head(sample_count)
+        sampled_historical_data = historical_data[historical_data[series_col].isin(sampled_groups.index)]
+
+        min_group = group_counts.idxmin()
+        min_series_data = historical_data[historical_data[series_col] == min_group]
+        unique_dates = min_series_data[date_col].unique()
+
+        cut_offs = self.generate_cutoffs(unique_dates, horizon)
+        training_datasets = [sampled_historical_data[sampled_historical_data[date_col] <= cut_off_date] for cut_off_date
+                             in cut_offs]
+        test_datasets = [sampled_historical_data[sampled_historical_data[date_col] > cut_offs[0]]]
+        for i, current in enumerate(cut_offs[1:]):
+            test_datasets.append(sampled_historical_data[(current < sampled_historical_data[date_col]) & (
+                    sampled_historical_data[date_col] <= cut_offs[i])])
+        all_additional = datasets.additional_data.data.reset_index()
+        sampled_additional_data = all_additional[all_additional[series_col].isin(sampled_groups.index)]
+        max_historical_date = sampled_historical_data[date_col].max()
+        additional_data = [sampled_additional_data[sampled_additional_data[date_col] <= max_historical_date]]
+        for cut_off in cut_offs[:-1]:
+            trimmed_additional_data = sampled_additional_data[sampled_additional_data[date_col] <= cut_off]
+            additional_data.append(trimmed_additional_data)
+        return cut_offs, training_datasets, additional_data, test_datasets
+
+    def remove_none_values(self, obj):
+        if isinstance(obj, dict):
+            return {k: self.remove_none_values(v) for k, v in obj.items() if k is not None and v is not None}
+        else:
+            return obj
+
+    def create_operator_config(self, operator_config, backtest, model, historical_data, additional_data, test_data):
+        output_dir = operator_config.spec.output_directory.url
+        output_file_path = f'{output_dir}/back_testing/{model}/{backtest}'
+        Path(output_file_path).mkdir(parents=True, exist_ok=True)
+        historical_data_url = f'{output_file_path}/historical.csv'
+        additional_data_url = f'{output_file_path}/additional.csv'
+        test_data_url = f'{output_file_path}/test.csv'
+        historical_data.to_csv(historical_data_url, index=False)
+        additional_data.to_csv(additional_data_url, index=False)
+        test_data.to_csv(test_data_url, index=False)
+        backtest_op_config_draft = operator_config.to_dict()
+        backtest_spec = backtest_op_config_draft["spec"]
+        backtest_spec["historical_data"]["url"] = historical_data_url
+        backtest_spec["additional_data"]["url"] = additional_data_url
+        backtest_spec["test_data"]["url"] = test_data_url
+        backtest_spec["model"] = model
+        backtest_spec['model_kwargs'] = None
+        backtest_spec["output_directory"] = {"url": output_file_path}
+        backtest_spec["target_category_columns"] = [DataColumns.Series]
+        backtest_spec['generate_explanations'] = False
+        cleaned_config = self.remove_none_values(backtest_op_config_draft)
+
+        backtest_op_config = ForecastOperatorConfig.from_dict(
+            obj_dict=cleaned_config)
+        return backtest_op_config
+
+    def run_all_models(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
+        cut_offs, train_sets, additional_data, test_sets = self.generate_k_fold_data(datasets, operator_config)
+        metrics = {}
+        for model in self.models:
+            from .model.factory import ForecastOperatorModelFactory
+            metrics[model] = {}
+            for i in range(len(cut_offs)):
+                backtest_historical_data = train_sets[i]
+                backtest_additional_data = additional_data[i]
+                backtest_test_data = test_sets[i]
+                backtest_operator_config = self.create_operator_config(operator_config, i, model,
+                                                                       backtest_historical_data,
+                                                                       backtest_additional_data,
+                                                                       backtest_test_data)
+                datasets = ForecastDatasets(backtest_operator_config)
+                ForecastOperatorModelFactory.get_model(
+                    backtest_operator_config, datasets
+                ).generate_report()
+                test_metrics_filename = backtest_operator_config.spec.test_metrics_filename
+                metrics_df = pd.read_csv(
+                    f"{backtest_operator_config.spec.output_directory.url}/{test_metrics_filename}")
+                metrics_df["average_across_series"] = metrics_df.drop('metrics', axis=1).mean(axis=1)
+                metrics_average_dict = dict(zip(metrics_df['metrics'].str.lower(), metrics_df['average_across_series']))
+                metrics[model][i] = metrics_average_dict[operator_config.spec.metric]
+        return metrics
+
+    def find_best_model(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
+        metrics = self.run_all_models(datasets, operator_config)
+        avg_backtests_metrics = {key: sum(value.values()) / len(value.values()) for key, value in metrics.items()}
+        best_model = min(avg_backtests_metrics, key=avg_backtests_metrics.get)
+        logger.info(f"Among models {self.models}, {best_model} model shows better performance during backtesting.")
+        backtest_stats = pd.DataFrame(metrics).rename_axis('backtest')
+        backtest_stats.reset_index(inplace=True)
+        output_dir = operator_config.spec.output_directory.url
+        backtest_report_name = "backtest_stats.csv"
+        backtest_stats.to_csv(f"{output_dir}/{backtest_report_name}", index=False)
+        return best_model

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

@@ -14,7 +14,7 @@ from ads.opctl.operator.common.operator_config import OperatorConfig, OutputDire
 
 from .const import SupportedMetrics, SpeedAccuracyMode
 from .const import SupportedModels
-
+from ads.opctl.operator.lowcode.common.utils import find_output_dirname
 
 @dataclass(repr=True)
 class TestData(InputData):
@@ -90,6 +90,7 @@ class ForecastOperatorSpec(DataClassSerializable):
 
     def __post_init__(self):
         """Adjusts the specification details."""
+        self.output_directory = self.output_directory or OutputDirectory(url=find_output_dirname(self.output_directory))
         self.metric = (self.metric or "").lower() or SupportedMetrics.SMAPE.lower()
         self.model = self.model or SupportedModels.Auto
         self.confidence_interval_width = self.confidence_interval_width or 0.80

ads/opctl/operator/lowcode/forecast/schema.yaml

@@ -365,14 +365,15 @@ spec:
     model:
       type: string
       required: false
-      default: auto
+      default: auto-select
       allowed:
         - prophet
         - arima
         - neuralprophet
+        - mlforecast
         - automlx
         - autots
-        - auto
+        - auto-select
 
     model_kwargs:
       type: dict
@@ -413,4 +414,8 @@ spec:
         - RMSE
         - MSE
         - SMAPE
+        - mape
+        - rmse
+        - mse
+        - smape
   type: dict

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

@@ -19,7 +19,6 @@ from sklearn.metrics import (
     mean_absolute_percentage_error,
     mean_squared_error,
 )
-
 try:
     from scipy.stats import linregress
 except:
@@ -34,8 +33,7 @@ from .errors import ForecastInputDataError, ForecastSchemaYamlError
 from .operator_config import ForecastOperatorSpec, ForecastOperatorConfig
 from ads.opctl.operator.lowcode.common.utils import merge_category_columns
 from ads.opctl.operator.lowcode.forecast.const import ForecastOutputColumns
-
-# from ads.opctl.operator.lowcode.forecast.model.forecast_datasets import TestData, ForecastOutput
+import report_creator as rc
 
 
 def _label_encode_dataframe(df, no_encode=set()):
@@ -258,8 +256,6 @@ def evaluate_train_metrics(output, metrics_col_name=None):
 
 
 def _select_plot_list(fn, series_ids):
-    import report_creator as rc
-
     blocks = [rc.Widget(fn(s_id=s_id), label=s_id) for s_id in series_ids]
     return rc.Select(blocks=blocks) if len(blocks) > 1 else blocks[0]
 
@@ -267,6 +263,23 @@ def _select_plot_list(fn, series_ids):
 def _add_unit(num, unit):
     return f"{num} {unit}"
 
+def get_auto_select_plot(backtest_results):
+    fig = go.Figure()
+    columns = backtest_results.columns.tolist()
+    back_test_column = "backtest"
+    columns.remove(back_test_column)
+    for i, column in enumerate(columns):
+        color = 0 #int(i * 255 / len(columns))
+        fig.add_trace(
+            go.Scatter(
+            x=backtest_results[back_test_column],
+            y=backtest_results[column],
+            mode="lines",
+            name=column,
+        ))
+
+    return rc.Widget(fig)
+
 
 def get_forecast_plots(
     forecast_output,
@@ -371,45 +384,6 @@ def get_forecast_plots(
 
     return _select_plot_list(plot_forecast_plotly, forecast_output.list_series_ids())
 
-
-def select_auto_model(
-    datasets: "ForecastDatasets", operator_config: ForecastOperatorConfig
-) -> str:
-    """
-    Selects AutoMLX or Arima model based on column count.
-
-    If the number of columns is less than or equal to the maximum allowed for AutoMLX,
-    returns 'AutoMLX'. Otherwise, returns 'Arima'.
-
-    Parameters
-    ------------
-    datasets:  ForecastDatasets
-            Datasets for predictions
-
-    Returns
-    --------
-    str
-        The type of the model.
-    """
-    freq_in_secs = datasets.get_datetime_frequency_in_seconds()
-    num_of_additional_cols = len(datasets.get_additional_data_column_names())
-    row_count = datasets.get_num_rows()
-    number_of_series = len(datasets.list_series_ids())
-    if (
-        num_of_additional_cols < 15
-        and row_count < 10000
-        and number_of_series < 10
-        and freq_in_secs > 3600
-    ):
-        return SupportedModels.AutoMLX
-    elif row_count < 10000 and number_of_series > 10:
-        return SupportedModels.AutoTS
-    elif row_count > 20000:
-        return SupportedModels.NeuralProphet
-    else:
-        return SupportedModels.NeuralProphet
-
-
 def convert_target(target: str, target_col: str):
     """
     Removes the target_column that got appended to target.

{oracle_ads-2.11.9.dist-info → oracle_ads-2.11.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oracle_ads
-Version: 2.11.9
+Version: 2.11.10
 Summary: Oracle Accelerated Data Science SDK
 Keywords: Oracle Cloud Infrastructure,OCI,Machine Learning,ML,Artificial Intelligence,AI,Data Science,Cloud,Oracle
 Author: Oracle Data Science
@@ -20,7 +20,7 @@ Requires-Dist: cloudpickle>=1.6.0
 Requires-Dist: fsspec>=0.8.7
 Requires-Dist: gitpython>=3.1.2
 Requires-Dist: jinja2>=2.11.2
-Requires-Dist: matplotlib>=3.1.3
+Requires-Dist: matplotlib>=3.1.3, <=3.8.4
 Requires-Dist: numpy>=1.19.2
 Requires-Dist: oci>=2.125.3
 Requires-Dist: ocifs>=1.1.3
@@ -34,10 +34,8 @@ Requires-Dist: tabulate>=0.8.9
 Requires-Dist: tqdm>=4.59.0
 Requires-Dist: oracle_ads[opctl] ; extra == "anomaly"
 Requires-Dist: autots ; extra == "anomaly"
-Requires-Dist: oracle-automlx[forecasting]==23.4.1 ; extra == "anomaly"
-Requires-Dist: oracle-automlx[classic]==23.4.1 ; extra == "anomaly"
 Requires-Dist: oracledb ; extra == "anomaly"
-Requires-Dist: report-creator ; extra == "anomaly"
+Requires-Dist: report-creator==1.0.9 ; extra == "anomaly"
 Requires-Dist: jupyter_server ; extra == "aqua"
 Requires-Dist: hdfs[kerberos] ; extra == "bds"
 Requires-Dist: ibis-framework[impala] ; extra == "bds"
@@ -61,14 +59,12 @@ Requires-Dist: oci-cli ; extra == "forecast"
 Requires-Dist: py-cpuinfo ; extra == "forecast"
 Requires-Dist: rich ; extra == "forecast"
 Requires-Dist: autots[additional] ; extra == "forecast"
-Requires-Dist: holidays==0.21.13 ; extra == "forecast"
-Requires-Dist: neuralprophet ; extra == "forecast"
+Requires-Dist: mlforecast ; extra == "forecast"
+Requires-Dist: neuralprophet>=0.7.0 ; extra == "forecast"
 Requires-Dist: numpy ; extra == "forecast"
 Requires-Dist: oci-cli ; extra == "forecast"
-Requires-Dist: optuna==3.1.0 ; extra == "forecast"
+Requires-Dist: optuna ; extra == "forecast"
 Requires-Dist: oracle-ads ; extra == "forecast"
-Requires-Dist: oracle-automlx[forecasting]==23.4.1 ; extra == "forecast"
-Requires-Dist: oracle-automlx[classic]==23.4.1 ; extra == "forecast"
 Requires-Dist: pmdarima ; extra == "forecast"
 Requires-Dist: prophet ; extra == "forecast"
 Requires-Dist: shap ; extra == "forecast"
@@ -76,13 +72,14 @@ Requires-Dist: sktime ; extra == "forecast"
 Requires-Dist: statsmodels ; extra == "forecast"
 Requires-Dist: plotly ; extra == "forecast"
 Requires-Dist: oracledb ; extra == "forecast"
-Requires-Dist: report-creator ; extra == "forecast"
+Requires-Dist: report-creator==1.0.9 ; extra == "forecast"
 Requires-Dist: geopandas ; extra == "geo"
 Requires-Dist: oracle_ads[viz] ; extra == "geo"
 Requires-Dist: transformers ; extra == "huggingface"
 Requires-Dist: langchain-community<0.0.32 ; extra == "llm"
 Requires-Dist: langchain>=0.1.10,<0.1.14 ; extra == "llm"
 Requires-Dist: evaluate>=0.4.0 ; extra == "llm"
+Requires-Dist: langchain-core<0.1.51 ; extra == "llm"
 Requires-Dist: ipython>=7.23.1, <8.0 ; extra == "notebook"
 Requires-Dist: ipywidgets~=7.6.3 ; extra == "notebook"
 Requires-Dist: lightgbm<4.0.0 ; extra == "onnx"
@@ -115,7 +112,7 @@ Requires-Dist: scrubadub==2.0.1 ; extra == "pii"
 Requires-Dist: scrubadub_spacy ; extra == "pii"
 Requires-Dist: spacy-transformers==1.2.5 ; extra == "pii"
 Requires-Dist: spacy==3.6.1 ; extra == "pii"
-Requires-Dist: report-creator ; extra == "pii"
+Requires-Dist: report-creator==1.0.9 ; extra == "pii"
 Requires-Dist: pyspark>=3.0.0 ; extra == "spark"
 Requires-Dist: oracle_ads[viz] ; extra == "tensorflow"
 Requires-Dist: tensorflow ; extra == "tensorflow"