oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.10__py3-none-any.whl

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

@@ -0,0 +1,397 @@
+#!/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 logging
+import os
+from typing import Set
+
+import numpy as np
+import pandas as pd
+import report_creator as rc
+from plotly import graph_objects as go
+from scipy.stats import linregress
+from sklearn.metrics import (
+    explained_variance_score,
+    mean_absolute_percentage_error,
+    mean_squared_error,
+    r2_score,
+)
+
+from ads.dataset.label_encoder import DataFrameLabelEncoder
+from ads.opctl import logger
+from ads.opctl.operator.lowcode.forecast.const import ForecastOutputColumns
+from ads.opctl.operator.lowcode.forecast.model.forecast_datasets import (
+    ForecastOutput,
+    TestData,
+)
+
+from .const import RENDER_LIMIT, SupportedMetrics
+
+logging.getLogger("report_creator").setLevel(logging.WARNING)
+
+
+def _label_encode_dataframe(df, no_encode: Set = None):
+    df_to_encode = df[list(set(df.columns) - no_encode)]
+    le = DataFrameLabelEncoder().fit(df_to_encode)
+    return le, le.transform(df)
+
+
+def _inverse_transform_dataframe(le, df):
+    return le.inverse_transform(df)
+
+
+def smape(actual, predicted) -> float:
+    if not all([isinstance(actual, np.ndarray), isinstance(predicted, np.ndarray)]):
+        actual, predicted = (np.array(actual), np.array(predicted))
+    zero_mask = np.logical_and(actual == 0, predicted == 0)
+
+    denominator = np.abs(actual) + np.abs(predicted)
+    denominator[zero_mask] = 1
+
+    numerator = np.abs(actual - predicted)
+
+    abs_error = np.divide(numerator, denominator)
+    return round(np.mean(abs_error) * 100, 2)
+
+
+def _build_metrics_per_horizon(
+    test_data: TestData,
+    output: ForecastOutput,
+) -> pd.DataFrame:
+    """
+    Calculates Mean sMAPE, Median sMAPE, Mean MAPE, Median MAPE, Mean wMAPE, Median wMAPE for each horizon
+
+    Parameters
+    ------------
+    data:  Pandas Dataframe
+            Dataframe that has the actual data
+    output: Pandas Dataframe
+            Dataframe that has the forecasted data
+
+    Returns
+    --------
+    Pandas Dataframe
+        Dataframe with Mean sMAPE, Median sMAPE, Mean MAPE, Median MAPE, Mean wMAPE, Median wMAPE values for each horizon
+    """
+    """
+    Assumptions:
+    data and output have all the target columns.
+    yhats in output are in the same order as in series_ids.
+    Test data might not have sorted dates and the order of series also might differ.
+    """
+
+    test_df = (
+        test_data.get_data_long()
+        .rename({test_data.dt_column_name: ForecastOutputColumns.DATE}, axis=1)
+        .set_index([ForecastOutputColumns.DATE, ForecastOutputColumns.SERIES])
+        .sort_index()
+    )
+    forecast_df = (
+        output.get_horizon_long()
+        .set_index([ForecastOutputColumns.DATE, ForecastOutputColumns.SERIES])
+        .sort_index()
+    )
+
+    dates = test_df.index.get_level_values(0).unique()
+    common_idx = test_df.index.intersection(forecast_df.index)
+
+    if len(common_idx) != len(forecast_df.index):
+        if len(dates) > output.horizon:
+            logger.debug(
+                f"Found more unique dates ({len(dates)}) in the Test Data than expected given the horizon ({output.horizon})."
+            )
+        elif len(dates) < output.horizon:
+            logger.debug(
+                f"Found fewer unique dates ({len(dates)}) in the Test Data than expected given the horizon ({output.horizon}). This will impact the metrics."
+            )
+        elif test_df.index.get_level_values(1).unique() > output.list_series_ids():
+            logger.debug(
+                f"Found more Series Ids in test data ({len(dates)}) expected from the historical data ({output.list_series_ids()})."
+            )
+        else:
+            logger.debug(
+                f"Found fewer Series Ids in test data ({len(dates)}) expected from the historical data ({output.list_series_ids()}). This will impact the metrics."
+            )
+
+    test_df = test_df.loc[common_idx]
+    forecast_df = forecast_df.loc[common_idx]
+
+    totals = test_df.sum(numeric_only=True)
+    wmape_weights = np.array((totals / totals.sum()).values)
+
+    metrics_df = pd.DataFrame()
+    for date in dates:
+        y_true = test_df.xs(date, level=ForecastOutputColumns.DATE)[
+            test_data.target_name
+        ]
+        y_pred = forecast_df.xs(date, level=ForecastOutputColumns.DATE)[
+            ForecastOutputColumns.FORECAST_VALUE
+        ]
+        y_true = np.array(y_true.values)
+        y_pred = np.array(y_pred.values)
+
+        drop_na_mask = ~np.isnan(y_true) & ~np.isnan(y_pred)
+        if not drop_na_mask.all():  # There is a missing value
+            if drop_na_mask.any():  # All values are missing
+                logger.debug(
+                    f"No test data available for date: {date}. This will affect the test metrics."
+                )
+                continue
+            logger.debug(
+                f"Missing test data for date: {date}. This will affect the test metrics."
+            )
+            y_true = y_true[drop_na_mask]
+            y_pred = y_pred[drop_na_mask]
+        smapes = smape(actual=y_true, predicted=y_pred)
+        mapes = mean_absolute_percentage_error(y_true=y_true, y_pred=y_pred)
+        wmapes = mapes * wmape_weights
+
+        metrics_df = pd.concat(
+            [
+                metrics_df,
+                pd.DataFrame(
+                    {
+                        SupportedMetrics.MEAN_SMAPE: np.mean(smapes),
+                        SupportedMetrics.MEDIAN_SMAPE: np.median(smapes),
+                        SupportedMetrics.MEAN_MAPE: np.mean(mapes),
+                        SupportedMetrics.MEDIAN_MAPE: np.median(mapes),
+                        SupportedMetrics.MEAN_WMAPE: np.mean(wmapes),
+                        SupportedMetrics.MEDIAN_WMAPE: np.median(wmapes),
+                    },
+                    index=[date],
+                ),
+            ]
+        )
+    return metrics_df
+
+
+def _build_metrics_df(y_true, y_pred, series_id):
+    if len(y_true) == 0 or len(y_pred) == 0:
+        return pd.DataFrame()
+    metrics = {}
+    metrics["sMAPE"] = smape(actual=y_true, predicted=y_pred)
+    metrics["MAPE"] = mean_absolute_percentage_error(y_true=y_true, y_pred=y_pred)
+    metrics["RMSE"] = np.sqrt(mean_squared_error(y_true=y_true, y_pred=y_pred))
+    try:
+        metrics["r2"] = linregress(y_true, y_pred).rvalue ** 2
+    except Exception:
+        metrics["r2"] = r2_score(y_true=y_true, y_pred=y_pred)
+    metrics["Explained Variance"] = explained_variance_score(
+        y_true=y_true, y_pred=y_pred
+    )
+    return pd.DataFrame.from_dict(metrics, orient="index", columns=[series_id])
+
+
+def evaluate_train_metrics(output):
+    """
+    Training metrics
+
+    Parameters:
+    output: ForecastOutputs
+
+    """
+    total_metrics = pd.DataFrame()
+    for s_id in output.list_series_ids():
+        try:
+            forecast_by_s_id = output.get_forecast(s_id)[
+                ["input_value", "Date", "fitted_value"]
+            ]
+            forecast_by_s_id = forecast_by_s_id.dropna()
+            y_true = forecast_by_s_id["input_value"].values
+            y_pred = forecast_by_s_id["fitted_value"].values
+            drop_na_mask = ~np.isnan(y_true) & ~np.isnan(y_pred)
+            if not drop_na_mask.all():  # There is a missing value
+                if drop_na_mask.any():  # All values are missing
+                    logger.debug(
+                        f"No fitted values available for series: {s_id}. This will affect the training metrics."
+                    )
+                    continue
+                logger.debug(
+                    f"Missing fitted values for series: {s_id}. This will affect the training metrics."
+                )
+                y_true = y_true[drop_na_mask]
+                y_pred = y_pred[drop_na_mask]
+            metrics_df = _build_metrics_df(
+                y_true=y_true,
+                y_pred=y_pred,
+                series_id=s_id,
+            )
+            total_metrics = pd.concat([total_metrics, metrics_df], axis=1)
+        except Exception as e:
+            logger.debug(
+                f"Failed to generate training metrics for target_series: {s_id}"
+            )
+            logger.debug(f"Recieved Error Statement: {e}")
+    return total_metrics
+
+
+def _select_plot_list(fn, series_ids, target_category_column):
+    blocks = [
+        rc.Widget(fn(s_id=s_id), label=s_id if target_category_column else None)
+        for s_id in series_ids
+    ]
+    return rc.Select(blocks=blocks) if len(blocks) > 1 else blocks[0]
+
+
+def _add_unit(num, unit):
+    return f"{num} {unit}"
+
+
+def get_auto_select_plot(backtest_results):
+    fig = go.Figure()
+    back_test_csv_columns = backtest_results.columns.tolist()
+    back_test_column = "backtest"
+    metric_column = "metric"
+    models = [
+        x for x in back_test_csv_columns if x not in [back_test_column, metric_column]
+    ]
+    for column in models:
+        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,
+    horizon,
+    test_data=None,
+    ci_interval_width=0.95,
+    target_category_column=None,
+):
+    def plot_forecast_plotly(s_id):
+        fig = go.Figure()
+        forecast_i = forecast_output.get_forecast(s_id)
+        actual_length = len(forecast_i)
+        if actual_length > RENDER_LIMIT:
+            forecast_i = forecast_i.tail(RENDER_LIMIT)
+            text = (
+                f"<i>To improve rendering speed, subsampled the data from {actual_length}"
+                f" rows to {RENDER_LIMIT} rows for this plot.</i>"
+            )
+            fig.update_layout(
+                annotations=[
+                    go.layout.Annotation(
+                        x=0.01,
+                        y=1.1,
+                        xref="paper",
+                        yref="paper",
+                        text=text,
+                        showarrow=False,
+                    )
+                ]
+            )
+        upper_bound = forecast_output.upper_bound_name
+        lower_bound = forecast_output.lower_bound_name
+        if upper_bound is not None and lower_bound is not None:
+            fig.add_traces(
+                [
+                    go.Scatter(
+                        x=forecast_i["Date"],
+                        y=forecast_i[lower_bound],
+                        mode="lines",
+                        line_color="rgba(0,0,0,0)",
+                        showlegend=False,
+                    ),
+                    go.Scatter(
+                        x=forecast_i["Date"],
+                        y=forecast_i[upper_bound],
+                        mode="lines",
+                        line_color="rgba(0,0,0,0)",
+                        name=f"{ci_interval_width * 100}% confidence interval",
+                        fill="tonexty",
+                        fillcolor="rgba(211, 211, 211, 0.5)",
+                    ),
+                ]
+            )
+        if test_data is not None:
+            try:
+                test_data_s_id = test_data.get_data_for_series(s_id)
+                fig.add_trace(
+                    go.Scatter(
+                        x=test_data_s_id[test_data.dt_column_name],
+                        y=test_data_s_id[test_data.target_name],
+                        mode="markers",
+                        marker_color="green",
+                        name="Actual",
+                    )
+                )
+            except Exception as e:
+                logger.debug(f"Unable to plot test data due to: {e.args}")
+
+        fig.add_trace(
+            go.Scatter(
+                x=forecast_i["Date"],
+                y=forecast_i["input_value"],
+                mode="markers",
+                marker_color="black",
+                name="Historical",
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=forecast_i["Date"],
+                y=forecast_i["fitted_value"],
+                mode="lines+markers",
+                line_color="blue",
+                name="Fitted Values",
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=forecast_i["Date"],
+                y=forecast_i["forecast_value"],
+                mode="lines+markers",
+                line_color="blue",
+                name="Forecast",
+            )
+        )
+        fig.add_vline(
+            x=forecast_i["Date"][-(horizon + 1) :].values[0],
+            line_width=1,
+            line_dash="dash",
+            line_color="gray",
+        )
+        return fig
+
+    return _select_plot_list(
+        plot_forecast_plotly, forecast_output.list_series_ids(), target_category_column
+    )
+
+
+def convert_target(target: str, target_col: str):
+    """
+    Removes the target_column that got appended to target.
+
+    Parameters
+    ------------
+    target: str
+        value in target_columns. i.e., "Sales_Product_Category_117"
+
+    target_col: str
+        target_column provided in yaml. i.e., "Sales"
+
+    Returns
+    --------
+        Original target. i.e., "Product_Category_117"
+    """
+    if target_col is not None and target_col != "":
+        temp = target_col + "_"
+        if temp in target:
+            target = target.replace(temp, "", 1)
+    return target
+
+
+def default_signer(**kwargs):
+    os.environ["EXTRA_USER_AGENT_INFO"] = "Forecast-Operator"
+    from ads.common.auth import default_signer
+
+    return default_signer(**kwargs)

ads/opctl/operator/lowcode/forecast/whatifserve/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+# 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 .deployment_manager import ModelDeploymentManager

ads/opctl/operator/lowcode/forecast/whatifserve/deployment_manager.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import os
+import pickle
+import shutil
+import sys
+import tempfile
+
+import cloudpickle
+import oci
+import pandas as pd
+from oci.data_science import DataScienceClient, DataScienceClientCompositeOperations
+from oci.data_science.models import (
+    CategoryLogDetails,
+    CreateModelDeploymentDetails,
+    FixedSizeScalingPolicy,
+    InstanceConfiguration,
+    LogDetails,
+    ModelConfigurationDetails,
+    SingleModelDeploymentConfigurationDetails,
+)
+
+from ads.common.model_export_util import prepare_generic_model
+from ads.common.object_storage_details import ObjectStorageDetails
+from ads.opctl import logger
+from ads.opctl.operator.common.utils import create_log_in_log_group
+from ads.opctl.operator.lowcode.common.utils import (
+    default_signer,
+    write_data,
+    write_simple_json,
+)
+
+from ..model.forecast_datasets import AdditionalData
+from ..operator_config import ForecastOperatorSpec
+
+
+class ModelDeploymentManager:
+    def __init__(
+        self,
+        spec: ForecastOperatorSpec,
+        additional_data: AdditionalData,
+        previous_model_version=None,
+    ):
+        self.spec = spec
+        self.model_name = spec.model
+        self.horizon = spec.horizon
+        self.additional_data = additional_data.get_dict_by_series()
+        self.model_obj = {}
+        self.display_name = spec.what_if_analysis.model_display_name
+        self.project_id = (
+            spec.what_if_analysis.project_id
+            if spec.what_if_analysis.project_id
+            else os.environ.get("PROJECT_OCID")
+        )
+        self.compartment_id = (
+            spec.what_if_analysis.compartment_id
+            if spec.what_if_analysis.compartment_id
+            else os.environ.get("NB_SESSION_COMPARTMENT_OCID")
+        )
+        if self.project_id is None or self.compartment_id is None:
+            raise ValueError("Either project_id or compartment_id cannot be None.")
+        self.path_to_artifact = f"{self.spec.output_directory.url}/artifacts/"
+        self.pickle_file_path = f"{self.spec.output_directory.url}/model.pkl"
+        self.model_version = previous_model_version + 1 if previous_model_version else 1
+        self.catalog_id = None
+        self.test_mode = os.environ.get("TEST_MODE", False)
+        self.deployment_info = {}
+
+    def _sanity_test(self):
+        """
+        Function perform sanity test for saved artifact
+        """
+        org_sys_path = sys.path[:]
+        try:
+            sys.path.insert(0, f"{self.path_to_artifact}")
+            from score import load_model, predict
+
+            _ = load_model()
+
+            # Write additional data to tmp file and perform sanity check
+            with tempfile.NamedTemporaryFile(suffix=".csv") as temp_file:
+                one_series = next(iter(self.additional_data))
+                sample_prediction_data = self.additional_data[one_series].tail(
+                    self.horizon
+                )
+                sample_prediction_data[self.spec.target_category_columns[0]] = (
+                    one_series
+                )
+                date_col_name = self.spec.datetime_column.name
+                date_col_format = self.spec.datetime_column.format
+                sample_prediction_data[date_col_name] = sample_prediction_data[
+                    date_col_name
+                ].dt.strftime(date_col_format)
+                sample_prediction_data.to_csv(temp_file.name, index=False)
+                input_data = {"additional_data": {"url": temp_file.name}}
+                prediction_test = predict(input_data, _)
+                logger.info(f"prediction test completed with result :{prediction_test}")
+        except Exception as e:
+            logger.error(f"An error occurred during the sanity test: {e}")
+            raise
+        finally:
+            sys.path = org_sys_path
+
+    def _copy_score_file(self):
+        """
+        Copies the score.py to the artifact_path.
+        """
+        try:
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            score_file = os.path.join(current_dir, "score.py")
+            destination_file = os.path.join(
+                self.path_to_artifact, os.path.basename(score_file)
+            )
+            shutil.copy2(score_file, destination_file)
+            logger.info(f"score.py copied successfully to {self.path_to_artifact}")
+        except Exception as e:
+            logger.warning(f"Error copying file: {e}")
+            raise e
+
+    def save_to_catalog(self):
+        """Save the model to a model catalog"""
+        with open(self.pickle_file_path, "rb") as file:
+            self.model_obj = pickle.load(file)
+
+        if not os.path.exists(self.path_to_artifact):
+            os.mkdir(self.path_to_artifact)
+
+        artifact_dict = {"spec": self.spec.to_dict(), "models": self.model_obj}
+        with open(f"{self.path_to_artifact}/models.pickle", "wb") as f:
+            cloudpickle.dump(artifact_dict, f)
+        artifact = prepare_generic_model(
+            self.path_to_artifact,
+            function_artifacts=False,
+            force_overwrite=True,
+            data_science_env=True,
+        )
+
+        self._copy_score_file()
+        self._sanity_test()
+
+        if isinstance(self.model_obj, dict):
+            series = self.model_obj.keys()
+        else:
+            series = self.additional_data.keys()
+        description = f"The object contains {len(series)} {self.model_name} models"
+
+        if not self.test_mode:
+            catalog_entry = artifact.save(
+                display_name=self.display_name,
+                compartment_id=self.compartment_id,
+                project_id=self.project_id,
+                description=description,
+            )
+            self.catalog_id = catalog_entry.id
+
+        logger.info(
+            f"Saved {self.model_name} version-v{self.model_version} to model catalog"
+            f" with model ocid : {self.catalog_id}"
+        )
+
+        self.deployment_info = {"model_ocid": self.catalog_id, "series": list(series)}
+
+    def create_deployment(self):
+        """Create a model deployment serving"""
+
+        # create new model deployment
+        initial_shape = self.spec.what_if_analysis.model_deployment.initial_shape
+        name = self.spec.what_if_analysis.model_deployment.display_name
+        description = self.spec.what_if_analysis.model_deployment.description
+        auto_scaling_config = self.spec.what_if_analysis.model_deployment.auto_scaling
+
+        # if auto_scaling_config is defined
+        if auto_scaling_config:
+            scaling_policy = oci.data_science.models.AutoScalingPolicy(
+                policy_type="AUTOSCALING",
+                auto_scaling_policies=[
+                    oci.data_science.models.ThresholdBasedAutoScalingPolicyDetails(
+                        auto_scaling_policy_type="THRESHOLD",
+                        rules=[
+                            oci.data_science.models.PredefinedMetricExpressionRule(
+                                metric_expression_rule_type="PREDEFINED_EXPRESSION",
+                                metric_type=auto_scaling_config.scaling_metric,
+                                scale_in_configuration=oci.data_science.models.PredefinedExpressionThresholdScalingConfiguration(
+                                    scaling_configuration_type="THRESHOLD",
+                                    threshold=auto_scaling_config.scale_in_threshold,
+                                ),
+                                scale_out_configuration=oci.data_science.models.PredefinedExpressionThresholdScalingConfiguration(
+                                    scaling_configuration_type="THRESHOLD",
+                                    threshold=auto_scaling_config.scale_out_threshold,
+                                ),
+                            )
+                        ],
+                        maximum_instance_count=auto_scaling_config.maximum_instance,
+                        minimum_instance_count=auto_scaling_config.minimum_instance,
+                        initial_instance_count=auto_scaling_config.minimum_instance,
+                    )
+                ],
+                cool_down_in_seconds=auto_scaling_config.cool_down_in_seconds,
+                is_enabled=True,
+            )
+            logger.info(
+                f"Using autoscaling {auto_scaling_config.scaling_metric} for creating MD"
+            )
+        else:
+            scaling_policy = FixedSizeScalingPolicy(instance_count=1)
+            logger.info("Using fixed size policy for creating MD")
+
+        model_configuration_details_object = ModelConfigurationDetails(
+            model_id=self.catalog_id,
+            instance_configuration=InstanceConfiguration(
+                instance_shape_name=initial_shape
+            ),
+            scaling_policy=scaling_policy,
+            bandwidth_mbps=20,
+        )
+
+        single_model_config = SingleModelDeploymentConfigurationDetails(
+            deployment_type="SINGLE_MODEL",
+            model_configuration_details=model_configuration_details_object,
+        )
+
+        log_group = self.spec.what_if_analysis.model_deployment.log_group
+        log_id = self.spec.what_if_analysis.model_deployment.log_id
+        if not log_id and not self.test_mode:
+            signer = oci.auth.signers.get_resource_principals_signer()
+            auth = {"signer": signer, "config": {}}
+            log_id = create_log_in_log_group(self.compartment_id, log_group, auth)
+
+        logs_configuration_details_object = CategoryLogDetails(
+            access=LogDetails(log_group_id=log_group, log_id=log_id),
+            predict=LogDetails(log_group_id=log_group, log_id=log_id),
+        )
+
+        model_deploy_configuration = CreateModelDeploymentDetails(
+            display_name=name,
+            description=description,
+            project_id=self.project_id,
+            compartment_id=self.compartment_id,
+            model_deployment_configuration_details=single_model_config,
+            category_log_details=logs_configuration_details_object,
+        )
+
+        if not self.test_mode:
+            auth = oci.auth.signers.get_resource_principals_signer()
+            data_science = DataScienceClient({}, signer=auth)
+            data_science_composite = DataScienceClientCompositeOperations(data_science)
+            model_deployment = (
+                data_science_composite.create_model_deployment_and_wait_for_state(
+                    model_deploy_configuration, wait_for_states=["SUCCEEDED", "FAILED"]
+                )
+            )
+            self.deployment_info["work_request"] = model_deployment.data.id
+            logger.info(f"deployment metadata :{model_deployment.data}")
+            md = data_science.get_model_deployment(
+                model_deployment_id=model_deployment.data.resources[0].identifier
+            )
+            self.deployment_info["model_deployment_ocid"] = md.data.id
+            self.deployment_info["status"] = md.data.lifecycle_state
+            endpoint_url = md.data.model_deployment_url
+            self.deployment_info["model_deployment_endpoint"] = (
+                f"{endpoint_url}/predict"
+            )
+            self.deployment_info["log_id"] = log_id
+
+    def save_deployment_info(self):
+        output_dir = self.spec.output_directory.url
+        if ObjectStorageDetails.is_oci_path(output_dir):
+            storage_options = default_signer()
+        else:
+            storage_options = {}
+        write_data(
+            data=pd.DataFrame.from_dict(self.deployment_info),
+            filename=os.path.join(output_dir, "deployment_info.json"),
+            format="json",
+            storage_options=storage_options,
+            index=False,
+            indent=4,
+            orient="records",
+        )
+        write_simple_json(
+            self.deployment_info, os.path.join(output_dir, "deployment_info.json")
+        )
+        logger.info(f"Saved deployment info to {output_dir}")