Merge branch 'main' into jupyter-slurm-integration

Author: zworacle

ads/aqua/common/enums.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2026 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 from typing import Dict, List
@@ -25,6 +25,7 @@ class PredictEndpoints(ExtendedEnum):
     TEXT_COMPLETIONS_ENDPOINT = "/v1/completions"
     EMBEDDING_ENDPOINT = "/v1/embedding"
     RESPONSES = "/v1/responses"
+    FORECAST = "v1/forecast"
 
 
 class Tags(ExtendedEnum):
@@ -47,6 +48,7 @@ class Tags(ExtendedEnum):
     MULTIMODEL_TYPE_TAG = "aqua_multimodel"
     STACKED_MODEL_TYPE_TAG = "aqua_stacked_model"
     AQUA_FINE_TUNE_MODEL_VERSION = "fine_tune_model_version"
+    MODEL_DEPLOY_PREDICT_ENDPOINT = "model_deploy_predict_endpoint"
 
 
 class InferenceContainerType(ExtendedEnum):

ads/aqua/modeldeployment/deployment.py

@@ -21,7 +21,12 @@
     ComputeShapeSummary,
     ContainerPath,
 )
-from ads.aqua.common.enums import InferenceContainerTypeFamily, ModelFormat, Tags
+from ads.aqua.common.enums import (
+    InferenceContainerTypeFamily,
+    ModelFormat,
+    PredictEndpoints,
+    Tags,
+)
 from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
 from ads.aqua.common.utils import (
     DEFINED_METADATA_TO_FILE_MAP,
@@ -274,6 +279,11 @@ def create(
                 create_deployment_details.env_var.update(
                     {Tags.TASK.upper(): ModelTask.TIME_SERIES_FORECASTING}
                 )
+                create_deployment_details.env_var.update(
+                    {
+                        Tags.MODEL_DEPLOY_PREDICT_ENDPOINT.upper(): PredictEndpoints.FORECAST
+                    }
+                )
             return self._create(
                 aqua_model=aqua_model,
                 create_deployment_details=create_deployment_details,

ads/dataset/dataset_browser.py

@@ -5,26 +5,27 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 
-from __future__ import print_function, absolute_import
+from __future__ import absolute_import, print_function
 
-import re, pathlib, os
+import os
+import pathlib
+import re
 import urllib.parse
 from abc import ABC, abstractmethod
 from os import listdir
-from os.path import isfile, isdir, join, getsize
-from typing import List, Set, Tuple, Dict
-
-import requests
+from os.path import getsize, isdir, isfile, join
+from typing import Dict, List, Set, Tuple
 
 import pandas as pd
+import requests
 import sklearn.datasets as sk_datasets
 
-from ads.dataset import helper
-from ads.common.utils import inject_and_copy_kwargs
 from ads.common.decorator.runtime_dependency import (
-    runtime_dependency,
     OptionalDependency,
+    runtime_dependency,
 )
+from ads.common.utils import inject_and_copy_kwargs
+from ads.dataset import helper
 
 
 class DatasetBrowser(ABC):
@@ -318,7 +319,7 @@ def open(self, name: str, **kwargs):
 
 class SklearnDatasets(DatasetBrowser):
 
-    sklearn_datasets = ["breast_cancer", "diabetes", "iris", "wine", "digits"]
+    sklearn_datasets = ["breast_cancer", "iris", "wine", "digits"]
 
     def __init__(self):
         super(DatasetBrowser, self).__init__()

ads/opctl/operator/lowcode/common/transformations.py

@@ -329,6 +329,8 @@ def build_fforms_meta_features(self, data, target_col=None, group_cols=None):
         if target_col not in data.columns:
             raise ValueError(f"Target column '{target_col}' not found in DataFrame")
 
+        data[target_col] = data[target_col].fillna(0)
+
         # Check if group_cols are provided and valid
         if group_cols is not None:
             if not isinstance(group_cols, list):

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

@@ -9,14 +9,13 @@
 import sys
 from typing import Dict, List
 
-import pandas as pd
 import yaml
 
 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 .const import AUTO_SELECT_SERIES
+from .const import AUTO_SELECT, AUTO_SELECT_SERIES
 from .model.forecast_datasets import ForecastDatasets, ForecastResults
 from .operator_config import ForecastOperatorConfig
 from .whatifserve import ModelDeploymentManager
@@ -29,8 +28,10 @@ def operate(operator_config: ForecastOperatorConfig) -> ForecastResults:
     datasets = ForecastDatasets(operator_config)
     model = ForecastOperatorModelFactory.get_model(operator_config, datasets)
 
-    if operator_config.spec.model == AUTO_SELECT_SERIES and hasattr(
-        operator_config.spec, "meta_features"
+    if (
+        operator_config.spec.model == AUTO_SELECT_SERIES
+        and hasattr(operator_config.spec, "meta_features")
+        and operator_config.spec.target_category_columns
     ):
         # For AUTO_SELECT_SERIES, handle each series with its specific model
         meta_features = operator_config.spec.meta_features
@@ -64,8 +65,6 @@ def operate(operator_config: ForecastOperatorConfig) -> ForecastResults:
             )
             sub_results_list.append(sub_results)
 
-            # results_df = pd.concat([results_df, sub_result_df], ignore_index=True, axis=0)
-            # elapsed_time += sub_elapsed_time
         # Merge all sub_results into a single ForecastResults object
         if sub_results_list:
             results = sub_results_list[0]
@@ -75,6 +74,20 @@ def operate(operator_config: ForecastOperatorConfig) -> ForecastResults:
             results = None
 
     else:
+        # When AUTO_SELECT_SERIES is specified but target_category_columns is not,
+        # we fall back to AUTO_SELECT behavior.
+        if (
+            operator_config.spec.model == AUTO_SELECT_SERIES
+            and not operator_config.spec.target_category_columns
+        ):
+
+            logger.warning(
+                "AUTO_SELECT_SERIES cannot be run with a single-series dataset or when "
+                "'target_category_columns' is not provided. Falling back to AUTO_SELECT."
+            )
+
+            operator_config.spec.model = AUTO_SELECT
+            model = ForecastOperatorModelFactory.get_model(operator_config, datasets)
         # For other cases, use the single selected model
         results = model.generate_report()
     # saving to model catalog

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

@@ -8,7 +8,7 @@ dependencies:
       - oracle-ads>=2.9.0
       - prophet
       - neuralprophet
-      - mlforecast
+      - mlforecast==1.0.2
       - pmdarima
       - statsmodels
       - report-creator

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

@@ -10,8 +10,10 @@
 import numpy as np
 import optuna
 import pandas as pd
+from pandas.tseries.frequencies import to_offset
 from joblib import Parallel, delayed
 from optuna.trial import TrialState
+from scipy.stats import linregress
 from sktime.split import ExpandingWindowSplitter
 from statsmodels.tsa.exponential_smoothing.ets import ETSModel
 
@@ -63,6 +65,39 @@ def preprocess(self, data, series_id):
         )
         return df_encoded.set_index(self.spec.datetime_column.name)
 
+    def _auto_detect_ets_params(self, y: pd.Series, seasonal_period: int) -> Dict[str, Any]:
+        """Detect trend, error type, and damping from data."""
+        params = {}
+
+        # Detect trend via linear regression significance
+        slope, _, r_value, p_value, _ = linregress(range(len(y)), y.values)
+        has_trend = p_value < 0.05
+        params["trend"] = "add" if has_trend else None
+        params["damped_trend"] = (has_trend and abs(r_value) < 0.7)  # weak trend → damp
+
+        # Detect additive vs multiplicative: does variance scale with level?
+        if seasonal_period and len(y) >= 2 * seasonal_period:
+            segments = [y.iloc[i:i + seasonal_period] for i in range(0, len(y) - seasonal_period, seasonal_period)]
+            means = np.array([s.mean() for s in segments])
+            stds = np.array([s.std() for s in segments])
+            if means.std() > 0:
+                corr = np.corrcoef(means, stds)[0, 1]
+                params["error"] = "mul" if corr > 0.7 else "add"
+                params["seasonal"] = params["error"]  # match seasonal to error type
+            else:
+                params["error"] = "add"
+                params["seasonal"] = "add"
+        else:
+            params["error"] = "add"
+            params["seasonal"] = "add"
+
+        # Multiplicative requires strictly positive data
+        if (y <= 0).any():
+            params["error"] = "add"
+            params["seasonal"] = "add"
+
+        return params
+
     def _train_model(self, i, series_id, df: pd.DataFrame, model_kwargs: Dict[str, Any]):
         try:
             self.forecast_output.init_series_output(series_id=series_id, data_at_series=df)
@@ -73,12 +108,24 @@ def _train_model(self, i, series_id, df: pd.DataFrame, model_kwargs: Dict[str, A
 
             Y = data_i[self.spec.target_column]
             dates = data_i.index.values
+            is_daily = False
+            if freq is not None:
+                try:
+                    is_daily = to_offset(freq).name in ["D", "B"]
+                except ValueError:
+                    pass
 
+            ets_model_args = self.spec.model_kwargs.get("restrict_daily_series_improvement_flow", True)
+            sp, probable_sps = find_seasonal_period_from_dataset(Y)
             if model_kwargs["seasonal"] is None:
                 model_kwargs["seasonal"] = "add"
-            if model_kwargs["seasonal_periods"] is None:
-                sp, probable_sps = find_seasonal_period_from_dataset(Y)
+
+            if ets_model_args and is_daily:
                 model_kwargs["seasonal_periods"] = sp if sp > 1 else None
+            else:
+                auto_params = self._auto_detect_ets_params(Y, sp)
+                for k, v in auto_params.items():
+                    model_kwargs[k] = v
 
             if self.loaded_models is not None and series_id in self.loaded_models:
                 previous_res = self.loaded_models[series_id].get("model")
@@ -92,14 +139,26 @@ def _train_model(self, i, series_id, df: pd.DataFrame, model_kwargs: Dict[str, A
                 if self.perform_tuning:
                     model_kwargs = self.run_tuning(Y, model_kwargs)
 
-            use_seasonal = (model_kwargs["seasonal"] is not None and
-                            model_kwargs["seasonal_periods"] is not None and
-                            len(Y) >= 2 * model_kwargs["seasonal_periods"]
-                            )
+            if (model_kwargs["error"] == "mul" or
+                model_kwargs["trend"] == "mul" or
+                model_kwargs["seasonal"] == "mul") and (Y <= 0).any():
+
+                logger.info("Multiplicative model incompatible with non-positive values. Switching to additive.")
+                model_kwargs["error"] = "add"
+                if model_kwargs["trend"] == "mul":
+                    model_kwargs["trend"] = "add"
+                if model_kwargs["seasonal"] == "mul":
+                    model_kwargs["seasonal"] = "add"
+
+            use_seasonal = (
+                    model_kwargs["seasonal"] is not None and
+                    model_kwargs["seasonal_periods"] is not None and
+                    model_kwargs["seasonal_periods"] > 1 and
+                    len(Y) >= max(2 * model_kwargs["seasonal_periods"], 10)
+            )
             if not use_seasonal:
                 model_kwargs["seasonal"] = None
                 model_kwargs["seasonal_periods"] = None
-
             model = ETSModel(Y, error=model_kwargs["error"], trend=model_kwargs["trend"],
                              damped_trend=model_kwargs["damped_trend"], seasonal=model_kwargs["seasonal"],
                              seasonal_periods=model_kwargs["seasonal_periods"],
@@ -145,7 +204,7 @@ def _train_model(self, i, series_id, df: pd.DataFrame, model_kwargs: Dict[str, A
                 if param in params:
                     params.pop(param)
             self.model_parameters[series_id] = {
-                "framework": SupportedModels.Arima,
+                "framework": SupportedModels.ETSForecaster,
                 **params,
             }