oracle-ads 2.13.17rc0__py3-none-any.whl → 2.13.18rc0__py3-none-any.whl

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

@@ -0,0 +1,310 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2023, 2025 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
+
+
+class MetaSelector:
+    """
+    A class to select the best forecasting model for each series based on pre-learned meta-rules.
+    The rules are based on the meta-features calculated by the FFORMS approach.
+    """
+
+    def __init__(self):
+        """Initialize the MetaSelector with pre-learned meta rules"""
+        # Pre-learned rules based on meta-features
+        self._meta_rules = {
+            # Rule 1: Strong trend, weak seasonality → ARIMA
+            "arima_0": {
+                "conditions": [
+                    ("ts_trend", "abs>=", 0.65),  # Strong trend strength
+                    ("ts_seasonal_strength", "<", 0.20),  # Weak seasonality
+                ],
+                "model": "arima",
+                "priority": 1,
+            },
+            # Rule 2: Strong seasonality, long series → Prophet
+            "prophet_0": {
+                "conditions": [
+                    ("ts_seasonal_strength", ">=", 0.50),  # Strong seasonality
+                    ("ts_n_obs", ">=", 200),  # Long series
+                ],
+                "model": "prophet",
+                "priority": 2,
+            },
+            # Rule 3: High entropy, low autocorrelation → AutoMLX
+            "automlx_0": {
+                "conditions": [
+                    ("ts_entropy", ">=", 4.0),  # High entropy
+                    ("ts_acf1", "<=", 0.30),  # Low autocorrelation
+                ],
+                "model": "automlx",
+                "priority": 3,
+            },
+            # Rule 4: Strong seasonality with trend and changing patterns → Prophet
+            "prophet_1": {
+                "conditions": [
+                    ("ts_seasonal_strength", ">=", 0.3),  # Strong seasonality
+                    ("ts_trend", "abs>=", 0.1),  # Clear trend
+                    ("ts_turning_points_rate", ">=", 0.2),  # Multiple change points
+                    ("ts_n_obs", ">=", 50),  # Sufficient data
+                    ("ts_step_max", ">=", 100),  # Significant steps
+                    ("ts_diff1_variance", ">=", 10),  # Variable differences
+                ],
+                "model": "prophet",
+                "priority": 4,
+            },
+            # Rule 5: Multiple seasonality with nonlinear patterns → Prophet
+            "prophet_2": {
+                "conditions": [
+                    ("ts_seasonal_peak_strength", ">=", 0.4),  # Strong peak seasonality
+                    ("ts_seasonal_strength", ">=", 0.2),  # Overall seasonality
+                    ("ts_acf10", ">=", 0.2),  # Long-term correlation
+                    ("ts_entropy", ">=", 0.5),  # Complex patterns
+                    ("ts_crossing_rate", ">=", 0.3),  # Frequent mean crossings
+                ],
+                "model": "prophet",
+                "priority": 5,
+            },
+            # Rule 6: Strong autocorrelation with stationary behavior → ARIMA
+            "arima_1": {
+                "conditions": [
+                    ("ts_acf1", ">=", 0.7),  # Strong lag-1 correlation
+                    ("ts_acf2", ">=", 0.5),  # Strong lag-2 correlation
+                    ("ts_seasonal_strength", "<", 0.3),  # Weak seasonality
+                    ("ts_std_residuals", "<", 500),  # Stable residuals
+                    ("ts_diff1_variance", "<", 100),  # Stable first differences
+                    ("ts_hurst", ">", -0.1),  # Some persistence
+                ],
+                "model": "arima",
+                "priority": 6,
+            },
+            # Rule 7: Linear trend with moderate noise → ARIMA
+            "arima_2": {
+                "conditions": [
+                    ("ts_trend", "abs>=", 0.15),  # Clear trend
+                    ("ts_trend_change", "<", 100),  # Stable trend
+                    ("ts_cv", "<", 0.4),  # Low variation
+                    ("ts_kurtosis", "<", 5),  # Normal-like distribution
+                    ("ts_nonlinearity", "<", 1e5),  # Linear relationships
+                ],
+                "model": "arima",
+                "priority": 7,
+            },
+            # Rule 8: Complex seasonality with high nonlinearity → NeuralProphet
+            "neuralprophet_1": {
+                "conditions": [
+                    ("ts_seasonal_peak_strength", ">=", 0.5),  # Strong seasonal peaks
+                    ("ts_nonlinearity", ">=", 1e6),  # Nonlinear patterns
+                    ("ts_n_obs", ">=", 200),  # Long series
+                    ("ts_entropy", ">=", 0.6),  # Complex patterns
+                    ("ts_diff2_variance", ">=", 50),  # Variable acceleration
+                ],
+                "model": "neuralprophet",
+                "priority": 8,
+            },
+            # Rule 9: Multiple seasonal patterns with changing behavior → NeuralProphet
+            "neuralprophet_2": {
+                "conditions": [
+                    ("ts_seasonal_strength", ">=", 0.4),  # Strong seasonality
+                    ("ts_turning_points_rate", ">=", 0.3),  # Many turning points
+                    ("ts_skewness", "abs>=", 1),  # Skewed distribution
+                    ("ts_diff1_mean", ">=", 10),  # Large changes
+                    ("ts_crossing_rate", ">=", 0.4),  # Frequent crossings
+                ],
+                "model": "neuralprophet",
+                "priority": 9,
+            },
+            # Rule 10: High volatility with complex patterns → AutoMLX
+            "automlx_1": {
+                "conditions": [
+                    ("ts_cv", ">=", 0.6),  # High variation
+                    ("ts_nonlinearity", ">=", 1e7),  # Strong nonlinearity
+                    ("ts_spikes_rate", ">=", 0.1),  # Frequent spikes
+                    ("ts_entropy", ">=", 0.7),  # Very complex
+                    ("ts_std_residuals", ">=", 1000),  # Large residuals
+                ],
+                "model": "automlx",
+                "priority": 10,
+            },
+            # Rule 11: Unstable patterns with regime changes → AutoMLX
+            "automlx_2": {
+                "conditions": [
+                    ("ts_trend_change", ">=", 200),  # Changing trend
+                    ("ts_turning_points_rate", ">=", 0.4),  # Many turning points
+                    ("ts_diff2_variance", ">=", 100),  # Variable acceleration
+                    ("ts_hurst", "<", -0.2),  # Anti-persistent
+                    ("ts_step_max", ">=", 1000),  # Large steps
+                ],
+                "model": "automlx",
+                "priority": 11,
+            },
+            # Rule 12: Long series with stable seasonality → AutoTS
+            "autots_1": {
+                "conditions": [
+                    ("ts_n_obs", ">=", 150),  # Long series
+                    ("ts_seasonal_strength", ">=", 0.2),  # Moderate seasonality
+                    ("ts_cv", "<", 0.5),  # Moderate variation
+                    ("ts_entropy", "<", 0.5),  # Not too complex
+                    ("ts_acf1", ">=", 0.3),  # Some autocorrelation
+                ],
+                "model": "autots",
+                "priority": 12,
+            },
+            # Rule 13: Stable patterns with low noise → Prophet
+            "prophet_3": {
+                "conditions": [
+                    ("ts_cv", "<", 0.3),  # Low variation
+                    ("ts_kurtosis", "<", 4),  # Normal-like
+                    ("ts_turning_points_rate", "<", 0.25),  # Few turning points
+                    ("ts_diff1_variance", "<", 50),  # Stable changes
+                    ("ts_seasonal_strength", ">=", 0.1),  # Some seasonality
+                ],
+                "model": "prophet",
+                "priority": 13,
+            },
+            # Rule 14: Short series with strong linear patterns → ARIMA
+            "arima_3": {
+                "conditions": [
+                    ("ts_n_obs", "<", 100),  # Short series
+                    ("ts_trend", "abs>=", 0.2),  # Strong trend
+                    ("ts_entropy", "<", 0.4),  # Simple patterns
+                    ("ts_nonlinearity", "<", 1e5),  # Linear
+                    ("ts_seasonal_strength", "<", 0.2),  # Weak seasonality
+                ],
+                "model": "arima",
+                "priority": 14,
+            },
+            # Rule 15: Complex seasonal patterns with long memory → NeuralProphet
+            "neuralprophet_3": {
+                "conditions": [
+                    ("ts_n_obs", ">=", 300),  # Very long series
+                    ("ts_seasonal_strength", ">=", 0.3),  # Clear seasonality
+                    ("ts_acf10", ">=", 0.3),  # Long memory
+                    ("ts_hurst", ">", 0),  # Persistent
+                    ("ts_nonlinearity", ">=", 5e5),  # Some nonlinearity
+                ],
+                "model": "neuralprophet",
+                "priority": 15,
+            },
+            # Rule 16: High complexity with non-normal distribution → AutoMLX
+            "automlx_3": {
+                "conditions": [
+                    ("ts_kurtosis", ">=", 5),  # Heavy tails
+                    ("ts_skewness", "abs>=", 2),  # Highly skewed
+                    ("ts_entropy", ">=", 0.6),  # Complex
+                    ("ts_spikes_rate", ">=", 0.05),  # Some spikes
+                    ("ts_diff2_mean", ">=", 5),  # Changing acceleration
+                ],
+                "model": "automlx",
+                "priority": 16,
+            },
+            # Rule 17: Simple patterns with weak seasonality → AutoTS
+            "autots_2": {
+                "conditions": [
+                    ("ts_entropy", "<", 0.3),  # Simple patterns
+                    ("ts_seasonal_strength", "<", 0.3),  # Weak seasonality
+                    ("ts_cv", "<", 0.4),  # Low variation
+                    ("ts_nonlinearity", "<", 1e5),  # Nearly linear
+                    ("ts_diff1_mean", "<", 10),  # Small changes
+                ],
+                "model": "autots",
+                "priority": 17,
+            },
+        }
+
+    def _evaluate_condition(self, value, operator, threshold):
+        """Evaluate a single condition based on pre-defined operators"""
+        if pd.isna(value):
+            return False
+
+        if operator == ">=":
+            return value >= threshold
+        elif operator == ">":
+            return value > threshold
+        elif operator == "<":
+            return value < threshold
+        elif operator == "<=":
+            return value <= threshold
+        elif operator == "abs>=":
+            return abs(value) >= threshold
+        elif operator == "abs<":
+            return abs(value) < threshold
+        return False
+
+    def _check_model_conditions(self, features, model_rules):
+        """Check if a series meets all conditions for a model"""
+        for feature, operator, threshold in model_rules["conditions"]:
+            if feature not in features:
+                return False
+            if not self._evaluate_condition(features[feature], operator, threshold):
+                return False
+        return True
+
+    def select_best_model(self, meta_features_df):
+        """
+        Select the best model for each series based on pre-learned rules.
+
+        Parameters
+        ----------
+        meta_features_df : pandas.DataFrame
+            DataFrame containing meta-features for each series, as returned by
+            build_fforms_meta_features
+
+        Returns
+        -------
+        pandas.DataFrame
+            DataFrame with series identifiers, selected model names, and matching rule info
+        """
+        results = []
+
+        # Process each series
+        for _, row in meta_features_df.iterrows():
+            series_info = {}
+
+            # Preserve group columns if they exist
+            group_cols = [col for col in row.index if not col.startswith("ts_")]
+            for col in group_cols:
+                series_info[col] = row[col]
+
+            # Find matching models
+            matching_models = []
+            matched_features = {}
+            for rule_name, rules in self._meta_rules.items():
+                if self._check_model_conditions(row, rules):
+                    matching_models.append((rule_name, rules["priority"]))
+                    # Store which features triggered this rule
+                    matched_features[rule_name] = [
+                        (feature, row[feature]) for feature, _, _ in rules["conditions"]
+                    ]
+
+            # Select best model based on priority
+            if matching_models:
+                best_rule = min(matching_models, key=lambda x: x[1])[0]
+                best_model = self._meta_rules[best_rule]["model"]
+                series_info["matched_features"] = matched_features[best_rule]
+            else:
+                best_rule = "default"
+                best_model = "prophet"  # Default to prophet if no rules match
+                series_info["matched_features"] = []
+
+            series_info["selected_model"] = best_model
+            series_info["rule_matched"] = best_rule
+            results.append(series_info)
+
+        return pd.DataFrame(results)
+
+    def get_model_conditions(self):
+        """
+        Get the pre-learned conditions for each model.
+        This is read-only and cannot be modified at runtime.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the conditions for each model
+        """
+        return self._meta_rules.copy()

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

@@ -158,7 +158,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
                 summary_frame = model.forecast(
                     X=X_pred,
                     periods=horizon,
-                    alpha=1 - (self.spec.confidence_interval_width / 100),
+                    alpha=1 - self.spec.confidence_interval_width,
                 )
 
                 fitted_values = model.predict(data_i.drop(target, axis=1))[

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

@@ -8,6 +8,7 @@ import os
 import tempfile
 import time
 import traceback
+import warnings
 from abc import ABC, abstractmethod
 from typing import Tuple
 
@@ -50,6 +51,7 @@ from ..const import (
     SpeedAccuracyMode,
     SupportedMetrics,
     SupportedModels,
+    TROUBLESHOOTING_GUIDE,
 )
 from ..operator_config import ForecastOperatorConfig, ForecastOperatorSpec
 from .forecast_datasets import ForecastDatasets, ForecastResults
@@ -98,10 +100,21 @@ class ForecastOperatorBaseModel(ABC):
             self.spec.tuning.n_trials is not None
         )
 
-    def generate_report(self):
-        """Generates the forecasting report."""
-        import warnings
+    def build_model(self):
+        """Builds the model and returns the result DataFrame and elapsed time."""
+        import time
 
+        start_time = time.time()
+        result_df = self._build_model()
+        elapsed_time = time.time() - start_time
+        logger.info("Building the models completed in %s seconds", elapsed_time)
+        return result_df, elapsed_time
+
+    def generate_report(
+        self, result_df=None, elapsed_time=None, save_sub_reports=False
+    ):
+        """Generates the forecasting report. Optionally accepts a precomputed result_df and elapsed_time.
+        If save_sub_reports is True, unique filenames are generated for all outputs."""
         from sklearn.exceptions import ConvergenceWarning
 
         with warnings.catch_warnings():
@@ -114,10 +127,8 @@ class ForecastOperatorBaseModel(ABC):
             if self.spec.previous_output_dir is not None:
                 self._load_model()
 
-            start_time = time.time()
-            result_df = self._build_model()
-            elapsed_time = time.time() - start_time
-            logger.info("Building the models completed in %s seconds", elapsed_time)
+            if result_df is None or elapsed_time is None:
+                result_df, elapsed_time = self.build_model()
 
             # Generate metrics
             summary_metrics = None
@@ -354,6 +365,7 @@ class ForecastOperatorBaseModel(ABC):
                 metrics_df=self.eval_metrics,
                 test_metrics_df=self.test_eval_metrics,
                 test_data=test_data,
+                save_sub_reports=save_sub_reports,
             )
 
     def _test_evaluate_metrics(self, elapsed_time=0):
@@ -471,8 +483,9 @@ class ForecastOperatorBaseModel(ABC):
         metrics_df: pd.DataFrame,
         test_metrics_df: pd.DataFrame,
         test_data: pd.DataFrame,
+        save_sub_reports: bool = False,
     ):
-        """Saves resulting reports to the given folder."""
+        """Saves resulting reports to the given folder. If save_sub_reports is True, use unique filenames."""
 
         unique_output_dir = self.spec.output_directory.url
         results = ForecastResults()
@@ -483,6 +496,12 @@ class ForecastOperatorBaseModel(ABC):
             else {}
         )
 
+        def get_path(filename):
+            path = os.path.join(unique_output_dir, filename)
+            if save_sub_reports:
+                return self._get_unique_filename(path, storage_options)
+            return path
+
         # report-creator html report
         if self.spec.generate_report:
             with tempfile.TemporaryDirectory() as temp_dir:
@@ -492,7 +511,7 @@ class ForecastOperatorBaseModel(ABC):
                     report.save(rc.Block(*report_sections), report_local_path)
                 enable_print()
 
-                report_path = os.path.join(unique_output_dir, self.spec.report_filename)
+                report_path = get_path(self.spec.report_filename)
                 write_file(
                     local_filename=report_local_path,
                     remote_filename=report_path,
@@ -511,9 +530,10 @@ class ForecastOperatorBaseModel(ABC):
             else result_df.drop(DataColumns.Series, axis=1)
         )
         if self.spec.generate_forecast_file:
+            forecast_path = get_path(self.spec.forecast_filename)
             write_data(
                 data=result_df,
-                filename=os.path.join(unique_output_dir, self.spec.forecast_filename),
+                filename=forecast_path,
                 format="csv",
                 storage_options=storage_options,
             )
@@ -531,11 +551,10 @@ class ForecastOperatorBaseModel(ABC):
                     {"index": "metrics", "Series 1": metrics_col_name}, axis=1
                 )
                 if self.spec.generate_metrics_file:
+                    metrics_path = get_path(self.spec.metrics_filename)
                     write_data(
                         data=metrics_df_formatted,
-                        filename=os.path.join(
-                            unique_output_dir, self.spec.metrics_filename
-                        ),
+                        filename=metrics_path,
                         format="csv",
                         storage_options=storage_options,
                         index=False,
@@ -553,11 +572,10 @@ class ForecastOperatorBaseModel(ABC):
                         {"index": "metrics", "Series 1": metrics_col_name}, axis=1
                     )
                     if self.spec.generate_metrics_file:
+                        test_metrics_path = get_path(self.spec.test_metrics_filename)
                         write_data(
                             data=test_metrics_df_formatted,
-                            filename=os.path.join(
-                                unique_output_dir, self.spec.test_metrics_filename
-                            ),
+                            filename=test_metrics_path,
                             format="csv",
                             storage_options=storage_options,
                             index=False,
@@ -567,6 +585,7 @@ class ForecastOperatorBaseModel(ABC):
                     logger.warning(
                         f"Attempted to generate the {self.spec.test_metrics_filename} file with the test metrics, however the test metrics could not be properly generated."
                     )
+
         # explanations csv reports
         if self.spec.generate_explanations:
             try:
@@ -579,11 +598,12 @@ class ForecastOperatorBaseModel(ABC):
                         else col
                     )
                     if self.spec.generate_explanation_files:
+                        global_exp_path = get_path(
+                            self.spec.global_explanation_filename
+                        )
                         write_data(
                             data=global_expl_rounded,
-                            filename=os.path.join(
-                                unique_output_dir, self.spec.global_explanation_filename
-                            ),
+                            filename=global_exp_path,
                             format="csv",
                             storage_options=storage_options,
                             index=True,
@@ -603,11 +623,10 @@ class ForecastOperatorBaseModel(ABC):
                         else col
                     )
                     if self.spec.generate_explanation_files:
+                        local_exp_path = get_path(self.spec.local_explanation_filename)
                         write_data(
                             data=local_expl_rounded,
-                            filename=os.path.join(
-                                unique_output_dir, self.spec.local_explanation_filename
-                            ),
+                            filename=local_exp_path,
                             format="csv",
                             storage_options=storage_options,
                             index=True,
@@ -625,9 +644,10 @@ class ForecastOperatorBaseModel(ABC):
 
         if self.spec.generate_model_parameters:
             # model params
+            model_params_path = get_path("model_params.json")
             write_data(
                 data=pd.DataFrame.from_dict(self.model_parameters),
-                filename=os.path.join(unique_output_dir, "model_params.json"),
+                filename=model_params_path,
                 format="json",
                 storage_options=storage_options,
                 index=True,
@@ -637,7 +657,13 @@ class ForecastOperatorBaseModel(ABC):
 
         # model pickle
         if self.spec.generate_model_pickle:
-            self._save_model(unique_output_dir, storage_options)
+            pickle_path = get_path("model.pkl")
+            write_pkl(
+                obj=self.models,
+                filename=os.path.basename(pickle_path),
+                output_dir=os.path.dirname(pickle_path),
+                storage_options=storage_options,
+            )
             results.set_models(self.models)
 
         logger.info(
@@ -648,11 +674,10 @@ class ForecastOperatorBaseModel(ABC):
             f"The outputs have been successfully generated and placed into the directory: {unique_output_dir}."
         )
         if self.errors_dict:
+            errors_path = get_path(self.spec.errors_dict_filename)
             write_json(
                 json_dict=self.errors_dict,
-                filename=os.path.join(
-                    unique_output_dir, self.spec.errors_dict_filename
-                ),
+                filename=errors_path,
                 storage_options=storage_options,
             )
             results.set_errors_dict(self.errors_dict)
@@ -719,6 +744,7 @@ class ForecastOperatorBaseModel(ABC):
             raise ValueError(
                 "AUTOMLX explanation accuracy mode is only supported for AutoMLX models. "
                 "Please select mode other than AUTOMLX from the available explanations_accuracy_mode options"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
 
     @runtime_dependency(
@@ -849,9 +875,9 @@ class ForecastOperatorBaseModel(ABC):
 
         # Add date column to local explanation DataFrame
         local_kernel_explnr_df[ForecastOutputColumns.DATE] = (
-            self.datasets.get_horizon_at_series(
-                s_id=series_id
-            )[self.spec.datetime_column.name].reset_index(drop=True)
+            self.datasets.get_horizon_at_series(s_id=series_id)[
+                self.spec.datetime_column.name
+            ].reset_index(drop=True)
         )
         self.local_explanation[series_id] = local_kernel_explnr_df
 
@@ -873,3 +899,66 @@ class ForecastOperatorBaseModel(ABC):
             return fcst
 
         return _custom_predict
+
+    def _get_unique_filename(self, base_path: str, storage_options: dict = None) -> str:
+        """Generate a unique filename by appending a sequential number if file exists.
+
+        Args:
+            base_path: The original file path to check
+            storage_options: Optional storage options for OCI paths
+
+        Returns:
+            A unique file path that doesn't exist
+        """
+        if not ObjectStorageDetails.is_oci_path(base_path):
+            # For local files
+            directory = os.path.dirname(base_path)
+            basename = os.path.basename(base_path)
+            name, ext = os.path.splitext(basename)
+
+            model_suffix = "_" + self.spec.model
+            new_name = f"{name}{model_suffix}"
+            new_path = os.path.join(directory, f"{new_name}{ext}")
+            counter = 1
+            while os.path.exists(new_path):
+                new_path = os.path.join(directory, f"{new_name}_{counter}{ext}")
+                counter += 1
+            return new_path
+        else:
+            # For OCI paths, we need to list objects and check
+            try:
+                from oci.object_storage import ObjectStorageClient
+
+                client = ObjectStorageClient(config=storage_options)
+
+                # Parse OCI path components
+                bucket_name = ObjectStorageDetails.get_bucket_name(base_path)
+                namespace = ObjectStorageDetails.get_namespace(base_path)
+                object_name = ObjectStorageDetails.get_object_name(base_path)
+
+                name, ext = os.path.splitext(object_name)
+
+                model_suffix = "_" + self.spec.model
+                new_name = f"{name}{model_suffix}"
+                new_object_name = f"{new_name}{ext}"
+                counter = 1
+                while True:
+                    try:
+                        # Try to head the object to see if it exists
+                        client.head_object(namespace, bucket_name, new_object_name)
+                        # If we get here, the object exists
+                        new_object_name = f"{new_name}_{counter}{ext}"
+                        counter += 1
+                    except:
+                        # Object doesn't exist, we can use this name
+                        break
+
+                # Reconstruct the full path
+                return ObjectStorageDetails.get_path(
+                    namespace, bucket_name, new_object_name
+                )
+            except Exception as e:
+                logger.warning(
+                    f"Error checking OCI path existence: {e}. Using original path."
+                )
+                return base_path

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

@@ -3,7 +3,16 @@
 # Copyright (c) 2023, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
-from ..const import AUTO_SELECT, SpeedAccuracyMode, SupportedModels
+from ads.opctl.operator.lowcode.common.transformations import Transformations
+
+from ..const import (
+    AUTO_SELECT,
+    AUTO_SELECT_SERIES,
+    TROUBLESHOOTING_GUIDE,
+    SpeedAccuracyMode,
+    SupportedModels,
+)
+from ..meta_selector import MetaSelector
 from ..model_evaluator import ModelEvaluator
 from ..operator_config import ForecastOperatorConfig
 from .arima import ArimaOperatorModel
@@ -21,6 +30,7 @@ class UnSupportedModelError(Exception):
         super().__init__(
             f"Model: `{model_type}` "
             f"is not supported. Supported models: {SupportedModels.values()}"
+            f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
         )
 
 
@@ -63,7 +73,28 @@ class ForecastOperatorModelFactory:
             In case of not supported model.
         """
         model_type = operator_config.spec.model
-        if model_type == AUTO_SELECT:
+
+        if model_type == AUTO_SELECT_SERIES:
+            # Initialize MetaSelector for series-specific model selection
+            selector = MetaSelector()
+            # Create a Transformations instance
+            transformer = Transformations(dataset_info=datasets.historical_data.spec)
+
+            # Calculate meta-features
+            meta_features = selector.select_best_model(
+                meta_features_df=transformer.build_fforms_meta_features(
+                    data=datasets.historical_data.raw_data,
+                    target_col=datasets.historical_data.spec.target_column,
+                    group_cols=datasets.historical_data.spec.target_category_columns
+                )
+            )
+            # Get the most common model as default
+            model_type = meta_features['selected_model'].mode().iloc[0]
+            # Store the series-specific model selections in the config for later use
+            operator_config.spec.meta_features = meta_features
+            operator_config.spec.model_kwargs = {}
+
+        elif model_type == AUTO_SELECT:
             model_type = cls.auto_select_model(datasets, operator_config)
             operator_config.spec.model_kwargs = {}
             # set the explanations accuracy mode to AUTOMLX if the selected model is automlx