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

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

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

@@ -18,13 +18,14 @@ from ads.opctl.operator.lowcode.common.utils import (
     get_frequency_of_datetime,
 )
 
-from ..const import ForecastOutputColumns, SupportedModels
+from ..const import ForecastOutputColumns, SupportedModels, TROUBLESHOOTING_GUIDE
 from ..operator_config import ForecastOperatorConfig
 
 
 class HistoricalData(AbstractData):
-    def __init__(self, spec, historical_data=None):
-        super().__init__(spec=spec, name="historical_data", data=historical_data)
+    def __init__(self, spec, historical_data=None, subset=None):
+        super().__init__(spec=spec, name="historical_data", data=historical_data, subset=subset)
+        self.subset = subset
 
     def _ingest_data(self, spec):
         try:
@@ -48,25 +49,29 @@ class HistoricalData(AbstractData):
                 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)
+            raise InvalidParameterError(f"{message}"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps.")
 
 
 class AdditionalData(AbstractData):
-    def __init__(self, spec, historical_data, additional_data=None):
+    def __init__(self, spec, historical_data, additional_data=None, subset=None):
+        self.subset = subset
         if additional_data is not None:
-            super().__init__(spec=spec, name="additional_data", data=additional_data)
+            super().__init__(spec=spec, name="additional_data", data=additional_data, subset=subset)
             self.additional_regressors = list(self.data.columns)
         elif spec.additional_data is not None:
-            super().__init__(spec=spec, name="additional_data")
+            super().__init__(spec=spec, name="additional_data", subset=subset)
             add_dates = self.data.index.get_level_values(0).unique().tolist()
             add_dates.sort()
             if historical_data.get_max_time() > add_dates[-spec.horizon]:
                 raise DataMismatchError(
                     f"The Historical Data ends on {historical_data.get_max_time()}. The additional data horizon starts on {add_dates[-spec.horizon]}. The horizon should have exactly {spec.horizon} dates after the Historical at a frequency of {historical_data.freq}"
+                    f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
                 )
             elif historical_data.get_max_time() != add_dates[-(spec.horizon + 1)]:
                 raise DataMismatchError(
                     f"The Additional Data must be present for all historical data and the entire horizon. The Historical Data ends on {historical_data.get_max_time()}. The additonal data horizon starts after {add_dates[-(spec.horizon+1)]}. These should be the same date."
+                    f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
                 )
         else:
             self.name = "additional_data"
@@ -114,8 +119,7 @@ class AdditionalData(AbstractData):
 
 class TestData(AbstractData):
     def __init__(self, spec, test_data):
-        if test_data is not None or spec.test_data is not None:
-            super().__init__(spec=spec, name="test_data", data=test_data)
+        super().__init__(spec=spec, name="test_data", data=test_data)
         self.dt_column_name = spec.datetime_column.name
         self.target_name = spec.target_column
 
@@ -127,6 +131,7 @@ class ForecastDatasets:
         historical_data=None,
         additional_data=None,
         test_data=None,
+        subset=None,  # New parameter for subsetting by group
     ):
         """Instantiates the DataIO instance.
 
@@ -134,26 +139,30 @@ class ForecastDatasets:
         ----------
         config: ForecastOperatorConfig
             The forecast operator configuration.
+        subset: list, optional
+            List of group keys to subset the data on initialization.
         """
+        self.config = config  # Store the config for later use
         self.historical_data: HistoricalData = None
         self.additional_data: AdditionalData = None
+        self.test_data: TestData = None
         self._horizon = config.spec.horizon
         self._datetime_column_name = config.spec.datetime_column.name
         self._target_col = config.spec.target_column
         if historical_data is not None:
-            self.historical_data = HistoricalData(config.spec, historical_data)
+            self.historical_data = HistoricalData(config.spec, historical_data, subset=subset)
             self.additional_data = AdditionalData(
-                config.spec, self.historical_data, additional_data
+                config.spec, self.historical_data, additional_data, subset=subset
             )
         else:
-            self._load_data(config.spec)
-        self.test_data = TestData(config.spec, test_data)
+            self._load_data(config.spec, subset=subset)
+        if test_data is not None or config.spec.test_data is not None:
+            self.test_data = TestData(config.spec, test_data)
 
-    def _load_data(self, spec):
+    def _load_data(self, spec, subset=None):
         """Loads forecasting input data."""
-        self.historical_data = HistoricalData(spec)
-        self.additional_data = AdditionalData(spec, self.historical_data)
-
+        self.historical_data = HistoricalData(spec, subset=subset)
+        self.additional_data = AdditionalData(spec, self.historical_data, subset=subset)
         if spec.generate_explanations and spec.additional_data is None:
             logger.warning(
                 "Unable to generate explanations as there is no additional data passed in. Either set generate_explanations to False, or pass in additional data."
@@ -210,6 +219,7 @@ class ForecastDatasets:
         except Exception as e:
             raise InvalidParameterError(
                 f"Unable to retrieve series id: {s_id} from data. Available series ids are: {self.list_series_ids()}"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             ) from e
 
     def get_horizon_at_series(self, s_id):
@@ -291,6 +301,7 @@ class ForecastOutput:
         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."
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
         forecast = self._check_forecast_format(forecast)
         self.series_id_map[series_id] = forecast
@@ -331,6 +342,7 @@ class ForecastOutput:
         except KeyError as e:
             raise ValueError(
                 f"Attempting to update output for series: {series_id}, however no series output has been initialized."
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             ) from e
 
         if (output_i.shape[0] - self.horizon) == len(fit_val):
@@ -351,18 +363,21 @@ class ForecastOutput:
         if len(forecast_val) != self.horizon:
             raise ValueError(
                 f"Attempting to set forecast along horizon ({self.horizon}) for series: {series_id}, however forecast is only length {len(forecast_val)}"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
         output_i["forecast_value"].iloc[-self.horizon :] = forecast_val
 
         if len(upper_bound) != self.horizon:
             raise ValueError(
                 f"Attempting to set upper_bound along horizon ({self.horizon}) for series: {series_id}, however upper_bound is only length {len(upper_bound)}"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
         output_i[self.upper_bound_name].iloc[-self.horizon :] = upper_bound
 
         if len(lower_bound) != self.horizon:
             raise ValueError(
                 f"Attempting to set lower_bound along horizon ({self.horizon}) for series: {series_id}, however lower_bound is only length {len(lower_bound)}"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
         output_i[self.lower_bound_name].iloc[-self.horizon :] = lower_bound
 
@@ -490,3 +505,25 @@ class ForecastResults:
 
     def get_errors_dict(self):
         return getattr(self, "errors_dict", None)
+
+    def merge(self, other: 'ForecastResults'):
+        """Merge another ForecastResults object into this one."""
+        # Merge DataFrames if they exist, else just set
+        for attr in [
+            'forecast', 'metrics', 'test_metrics', 'local_explanations', 'global_explanations', 'model_parameters', 'models', 'errors_dict']:
+            val_self = getattr(self, attr, None)
+            val_other = getattr(other, attr, None)
+            if val_self is not None and val_other is not None:
+                if isinstance(val_self, pd.DataFrame) and isinstance(val_other, pd.DataFrame):
+                    setattr(self, attr, pd.concat([val_self, val_other], ignore_index=True, axis=0))
+                elif isinstance(val_self, dict) and isinstance(val_other, dict):
+                    val_self.update(val_other)
+                    setattr(self, attr, val_self)
+                elif isinstance(val_self, list) and isinstance(val_other, list):
+                    setattr(self, attr, val_self + val_other)
+                else:
+                    # If not mergeable, just keep self's value
+                    pass
+            elif val_other is not None:
+                setattr(self, attr, val_other)
+        return self

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

@@ -10,7 +10,10 @@ import pandas as pd
 from ads.opctl import logger
 from ads.opctl.operator.lowcode.common.const import DataColumns
 from ads.opctl.operator.lowcode.common.errors import InsufficientDataError
-from ads.opctl.operator.lowcode.forecast.const import BACKTEST_REPORT_NAME
+from ads.opctl.operator.lowcode.forecast.const import (
+    BACKTEST_REPORT_NAME,
+    TROUBLESHOOTING_GUIDE,
+)
 from ads.opctl.operator.lowcode.forecast.model.factory import SupportedModels
 
 from .model.forecast_datasets import ForecastDatasets
@@ -79,6 +82,7 @@ class ModelEvaluator:
             raise InsufficientDataError(
                 "Insufficient data to evaluate multiple models. Please specify a model "
                 "instead of using auto-select."
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
         training_datasets = [
             sampled_historical_data[sampled_historical_data[date_col] <= cut_off_date]
@@ -223,6 +227,7 @@ class ModelEvaluator:
             model = SupportedModels.Prophet
             logger.error(
                 f"Running {model} model as auto-select failed with the following error: {e.message}"
+                f"\nPlease refer to the troubleshooting guide at {TROUBLESHOOTING_GUIDE} for resolution steps."
             )
             return model
         nonempty_metrics = {

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

@@ -459,6 +459,7 @@ spec:
         - automlx
         - autots
         - auto-select
+        - auto-select-series
 
     model_kwargs:
       type: dict

ads/pipeline/ads_pipeline.py

@@ -1728,15 +1728,19 @@ class Pipeline(Builder):
 
     def __step_infrastructure_configuration_details(self, step) -> dict:
         step_infrastructure_configuration_details = {}
-        step_infrastructure_configuration_details[
-            "blockStorageSizeInGBs"
-        ] = step.infrastructure.block_storage_size
-        step_infrastructure_configuration_details[
-            "shapeName"
-        ] = step.infrastructure.shape_name
-        step_infrastructure_configuration_details[
-            "shapeConfigDetails"
-        ] = step.infrastructure.shape_config_details
+        step_infrastructure_configuration_details["blockStorageSizeInGBs"] = (
+            step.infrastructure.block_storage_size
+        )
+        step_infrastructure_configuration_details["shapeName"] = (
+            step.infrastructure.shape_name
+        )
+        step_infrastructure_configuration_details["shapeConfigDetails"] = (
+            step.infrastructure.shape_config_details
+        )
+        if getattr(step.infrastructure, "subnet_id", ""):
+            step_infrastructure_configuration_details["subnetId"] = (
+                step.infrastructure.subnet_id
+            )
         return step_infrastructure_configuration_details
 
     def __step_configuration_details(self, pipeline_details: Dict, step) -> dict:

{oracle_ads-2.13.17rc0.dist-info → oracle_ads-2.13.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oracle_ads
-Version: 2.13.17rc0
+Version: 2.13.18
 Summary: Oracle Accelerated Data Science SDK
 Keywords: Oracle Cloud Infrastructure,OCI,Machine Learning,ML,Artificial Intelligence,AI,Data Science,Cloud,Oracle,GenAI,Generative AI,Forecast,Anomaly,Document Understanding,Anomaly Detection
 Author: Oracle Data Science