From da62d6bd15bc97d5215185d07f2c1428b1cc3404 Mon Sep 17 00:00:00 2001 From: bial_fr Date: Fri, 9 Oct 2026 10:56:34 +0200 Subject: [PATCH 1/2] Robust optimization 1.1.2 --- docs/tutorial_stochastic.ipynb | 26 +++++++++++++------------- sb_arch_opt/uncertainty.py | 12 ++++++++---- 2 files changed, 21 insertions(+), 17 deletions(-) diff --git a/docs/tutorial_stochastic.ipynb b/docs/tutorial_stochastic.ipynb index 397cccd..01b981d 100644 --- a/docs/tutorial_stochastic.ipynb +++ b/docs/tutorial_stochastic.ipynb @@ -16,7 +16,7 @@ "pip install sb-arch-opt[uncertainty,arch_sbo]\n", "```" ], - "id": "cb2dfcb356ad626b" + "id": "db466bb89c101cb" }, { "metadata": {}, @@ -27,7 +27,7 @@ "import warnings\n", "warnings.filterwarnings('ignore')" ], - "id": "853186ccc64b311b" + "id": "396234b6541e0467" }, { "metadata": {}, @@ -47,7 +47,7 @@ "\n", "Below, `MDMOHimmelblau` is wrapped in such a class. Its continuous design variable is realized with a normally-distributed deviation from its nominal value, and the underlying problem is then evaluated at the realized design vector. Since the design space of the underlying problem is reused, the design variables and the correction of design vectors are inherited as-is and `_correct_x` does not need to be implemented." ], - "id": "56d6dab3b1e5f7b" + "id": "facf22f1138d64ab" }, { "metadata": {}, @@ -91,7 +91,7 @@ " def __repr__(self):\n", " return f'{self.__class__.__name__}(std={self.std}, n={self.uq_method.n_evaluations})'" ], - "id": "7c735da49e170b2b" + "id": "f1cccabfdb4a5c3d" }, { "metadata": {}, @@ -105,13 +105,13 @@ "problem = StochasticMDMOHimmelblau(std=.3, n=12)\n", "problem.print_stats()" ], - "id": "2db9a8d421e3f270" + "id": "d61d697783cce330" }, { "metadata": {}, "cell_type": "markdown", "source": "The resulting problem has the same design variables and objectives as the deterministic one, only the evaluation has changed. Note that one design point now costs 12 evaluations of the underlying problem to train the PCE surrogate. Then the cheap PCE model is evaluated with 1000 samples to construct the distribution. Note that the uncertainty propagation requires overall more model evaluation which makes Surrogate-Based Optimization (SBO) especially attractive for stochastic problems.", - "id": "d0ecd1d63f400dc5" + "id": "b0e4195cfe033d87" }, { "metadata": {}, @@ -121,7 +121,7 @@ "\n", "The stochastic problem is an `ArchOptProblemBase` subclass, so the algorithms in SBArchOpt can be used without modification. The code below runs the pre-configured NSGA2 and compares the resulting robust Pareto front to the known deterministic Pareto front of `MDMOHimmelblau`." ], - "id": "d58823d06acbc6ed" + "id": "b56c003aa9ddddae" }, { "metadata": {}, @@ -135,7 +135,7 @@ "# Create the pre-configured NSGA2 algorithm\n", "nsga2 = get_nsga2(pop_size=100)\n", "\n", - "# Run the optimization: 20 generations (20 x 100 = 2000 design points, each with 50 realizations)\n", + "# Run the optimization: 20 generations (20 x 100 = 2000 design points, each with 12 realizations)\n", "# NOTE: remove \"seed\" argument when using in production!\n", "result_nsga2 = minimize(problem, nsga2, termination=('n_gen', 20), seed=42)\n", "\n", @@ -144,13 +144,13 @@ "plot(pf_deterministic, result_nsga2.opt.get('F'),\n", " labels=['Deterministic Pareto front', 'NSGA2 robust (2000 design points)'])" ], - "id": "762c1b2ad0127509" + "id": "5993ed15435ce83f" }, { "metadata": {}, "cell_type": "markdown", "source": "The robust Pareto front lies above the deterministic one, which clearly shows that the perturbation in design vector has effect on the objectives. The deterministic front is therefore not achievable in practice, and optimizing towards it would select designs that are more sensitive to the perturbations.", - "id": "a4f99e6120985213" + "id": "46f3ba97d7a28c21" }, { "metadata": {}, @@ -160,7 +160,7 @@ "\n", "Because every design point requires 12 evaluations for each sample realization, the number of design points for evaluation should be kept low. Surrogate-Based Optimization (SBO) in general requires fewer evaluations than genetic algorithms to find the Pareto front, therefore they are well suited for the stochastic optimization problems." ], - "id": "efe12d81968cda69" + "id": "8699076db149ac3b" }, { "metadata": {}, @@ -184,13 +184,13 @@ " labels=['Deterministic Pareto front', 'NSGA2 robust (2000 design points)',\n", " 'SBO robust (50 design points)'])" ], - "id": "68b1694f096c0818" + "id": "af98e2db55f89153" }, { "metadata": {}, "cell_type": "markdown", "source": "SBO reaches the same robust Pareto front as NSGA2 using 40 times fewer design points. Given that for each design points 12 evaluations are performed to propagate uncertainty, the computational budget savings are tremendous compared with NSGA-2 (overall 480 less evaluations).", - "id": "d4f0ff16942cc3c4" + "id": "1d4414e5f0c9fc9f" } ], "metadata": {}, diff --git a/sb_arch_opt/uncertainty.py b/sb_arch_opt/uncertainty.py index aaa18e0..273c893 100644 --- a/sb_arch_opt/uncertainty.py +++ b/sb_arch_opt/uncertainty.py @@ -142,9 +142,10 @@ class StochasticOutput: :param dist: the output distribution for the specific objective or constraint. """ - def __init__(self, dist: ot.Distribution, method_results=None): + def __init__(self, dist: ot.Distribution, samples: np.ndarray, method_results=None): check_dependency() self.dist = dist + self.samples = samples self.method_results = method_results @staticmethod @@ -168,10 +169,11 @@ def from_output_samples(cls, output_samples: ot.Sample, method_results=None) -> a float value is returned to represent deterministic output. If any sample is nan, np.nan is returned. """ + values = np.asarray(output_samples, dtype=float).ravel() dist = cls.build_distribution(output_samples) if isinstance(dist, float): return dist - return cls(dist=dist, method_results=method_results) + return cls(dist=dist, samples=values, method_results=method_results) @property def mean(self) -> float: @@ -259,14 +261,16 @@ class Quantile(Scalarization): """ - def __init__(self, q: float = 0.95): + def __init__(self, q: float = 0.95, direction: int =-1): super().__init__() if not 0. <= q <= 1.: raise ValueError(f'Quantile should be between 0 and 1: {q}') self.q = q + self.direction = direction def scalarize(self, output: StochasticOutput) -> float: - return float(output.quantile(self.q)) + q = self.q if self.direction == -1 else 1 - self.q + return float(output.quantile(q)) def __repr__(self): return f"Quantile with q = {self.q}" From b694bdfcec32553f2d5235e50067f8b459987e47 Mon Sep 17 00:00:00 2001 From: bial_fr Date: Fri, 9 Oct 2026 10:56:34 +0200 Subject: [PATCH 2/2] Robust optimization 1.1.2 --- docs/tutorial_stochastic.ipynb | 305 ++++++++++++++++++++++++++++----- sb_arch_opt/uncertainty.py | 12 +- 2 files changed, 267 insertions(+), 50 deletions(-) diff --git a/docs/tutorial_stochastic.ipynb b/docs/tutorial_stochastic.ipynb index 397cccd..3fba1ce 100644 --- a/docs/tutorial_stochastic.ipynb +++ b/docs/tutorial_stochastic.ipynb @@ -1,8 +1,9 @@ { "cells": [ { - "metadata": {}, "cell_type": "markdown", + "id": "db466bb89c101cb", + "metadata": {}, "source": [ "# Stochastic Optimization Tutorial\n", "\n", @@ -15,23 +16,30 @@ "```\n", "pip install sb-arch-opt[uncertainty,arch_sbo]\n", "```" - ], - "id": "cb2dfcb356ad626b" + ] }, { - "metadata": {}, "cell_type": "code", + "execution_count": 1, + "id": "396234b6541e0467", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T08:55:37.626407Z", + "iopub.status.busy": "2026-10-09T08:55:37.626407Z", + "iopub.status.idle": "2026-10-09T08:55:37.636807Z", + "shell.execute_reply": "2026-10-09T08:55:37.635784Z" + } + }, "outputs": [], - "execution_count": null, "source": [ "import warnings\n", "warnings.filterwarnings('ignore')" - ], - "id": "853186ccc64b311b" + ] }, { - "metadata": {}, "cell_type": "markdown", + "id": "facf22f1138d64ab", + "metadata": {}, "source": [ "## The Stochastic Problem Class\n", "\n", @@ -46,14 +54,21 @@ "Evaluation is implemented in `_arch_evaluate_sample` instead of `_arch_evaluate`. This function is called once per realization of the uncertain parameters, receives it in `parameters`, and writes the responses for that realization only.\n", "\n", "Below, `MDMOHimmelblau` is wrapped in such a class. Its continuous design variable is realized with a normally-distributed deviation from its nominal value, and the underlying problem is then evaluated at the realized design vector. Since the design space of the underlying problem is reused, the design variables and the correction of design vectors are inherited as-is and `_correct_x` does not need to be implemented." - ], - "id": "56d6dab3b1e5f7b" + ] }, { - "metadata": {}, "cell_type": "code", + "execution_count": 2, + "id": "f1cccabfdb4a5c3d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T08:55:37.643824Z", + "iopub.status.busy": "2026-10-09T08:55:37.642805Z", + "iopub.status.idle": "2026-10-09T08:55:39.436248Z", + "shell.execute_reply": "2026-10-09T08:55:39.436248Z" + } + }, "outputs": [], - "execution_count": null, "source": [ "import numpy as np\n", "import openturns as ot\n", @@ -90,44 +105,96 @@ "\n", " def __repr__(self):\n", " return f'{self.__class__.__name__}(std={self.std}, n={self.uq_method.n_evaluations})'" - ], - "id": "7c735da49e170b2b" + ] }, { - "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, + "execution_count": 3, + "id": "d61d697783cce330", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T08:55:39.438525Z", + "iopub.status.busy": "2026-10-09T08:55:39.438525Z", + "iopub.status.idle": "2026-10-09T08:55:39.442542Z", + "shell.execute_reply": "2026-10-09T08:55:39.442542Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "problem: StochasticMDMOHimmelblau(std=0.3, n=12)\n", + "n_discr: 1\n", + "n_cont : 1\n", + "n_obj : 2\n", + "n_con : 0\n", + "MD : True\n", + "MO : True\n", + "HIER : False\n", + "n_valid_discr: 10\n", + "imp_ratio : 1.00 (discr.: 1.00; cont.: 1.00)\n", + "corr_ratio : 1.00 (discr.: 1.00; cont.: 1.00; fraction of imp_ratio: 0.0%)\n", + "stochastic : True\n", + "n_stochastic_params : 1\n", + "uq_method : Polynomial Chaos Expansion\n", + "n_uq_samples : 12\n", + "obj_scalarize : [Mean, Mean]\n", + "ieq_constr_scalarize : []\n", + "eq_constr_scalarize : []\n" + ] + } + ], "source": [ "# Instantiate the problem class and print some statistics\n", "# Sample size for degree d PCE regression: N = 2P to 3P, where\n", "# P = (n+d)! / (n! d!) is the number of polynomial terms for n parameters.\n", "problem = StochasticMDMOHimmelblau(std=.3, n=12)\n", "problem.print_stats()" - ], - "id": "2db9a8d421e3f270" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "The resulting problem has the same design variables and objectives as the deterministic one, only the evaluation has changed. Note that one design point now costs 12 evaluations of the underlying problem to train the PCE surrogate. Then the cheap PCE model is evaluated with 1000 samples to construct the distribution. Note that the uncertainty propagation requires overall more model evaluation which makes Surrogate-Based Optimization (SBO) especially attractive for stochastic problems.", - "id": "d0ecd1d63f400dc5" + "id": "b0e4195cfe033d87", + "metadata": {}, + "source": [ + "The resulting problem has the same design variables and objectives as the deterministic one, only the evaluation has changed. Note that one design point now costs 12 evaluations of the underlying problem to train the PCE surrogate. Then the cheap PCE model is evaluated with 1000 samples to construct the distribution. Note that the uncertainty propagation requires overall more model evaluation which makes Surrogate-Based Optimization (SBO) especially attractive for stochastic problems." + ] }, { - "metadata": {}, "cell_type": "markdown", + "id": "b56c003aa9ddddae", + "metadata": {}, "source": [ "## Solving with NSGA2\n", "\n", "The stochastic problem is an `ArchOptProblemBase` subclass, so the algorithms in SBArchOpt can be used without modification. The code below runs the pre-configured NSGA2 and compares the resulting robust Pareto front to the known deterministic Pareto front of `MDMOHimmelblau`." - ], - "id": "d58823d06acbc6ed" + ] }, { - "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, + "execution_count": 4, + "id": "5993ed15435ce83f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T08:55:39.444777Z", + "iopub.status.busy": "2026-10-09T08:55:39.444777Z", + "iopub.status.idle": "2026-10-09T08:56:05.618866Z", + "shell.execute_reply": "2026-10-09T08:56:05.618866Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from pymoo.optimize import minimize\n", "from sb_arch_opt.algo.pymoo_interface import plot, get_nsga2\n", @@ -135,7 +202,7 @@ "# Create the pre-configured NSGA2 algorithm\n", "nsga2 = get_nsga2(pop_size=100)\n", "\n", - "# Run the optimization: 20 generations (20 x 100 = 2000 design points, each with 50 realizations)\n", + "# Run the optimization: 20 generations (20 x 100 = 2000 design points, each with 12 realizations)\n", "# NOTE: remove \"seed\" argument when using in production!\n", "result_nsga2 = minimize(problem, nsga2, termination=('n_gen', 20), seed=42)\n", "\n", @@ -143,30 +210,162 @@ "pf_deterministic = MDMOHimmelblau().pareto_front()\n", "plot(pf_deterministic, result_nsga2.opt.get('F'),\n", " labels=['Deterministic Pareto front', 'NSGA2 robust (2000 design points)'])" - ], - "id": "762c1b2ad0127509" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "The robust Pareto front lies above the deterministic one, which clearly shows that the perturbation in design vector has effect on the objectives. The deterministic front is therefore not achievable in practice, and optimizing towards it would select designs that are more sensitive to the perturbations.", - "id": "a4f99e6120985213" + "id": "46f3ba97d7a28c21", + "metadata": {}, + "source": [ + "The robust Pareto front lies above the deterministic one, which clearly shows that the perturbation in design vector has effect on the objectives. The deterministic front is therefore not achievable in practice, and optimizing towards it would select designs that are more sensitive to the perturbations." + ] }, { - "metadata": {}, "cell_type": "markdown", + "id": "8699076db149ac3b", + "metadata": {}, "source": [ "## Solving with SBO\n", "\n", "Because every design point requires 12 evaluations for each sample realization, the number of design points for evaluation should be kept low. Surrogate-Based Optimization (SBO) in general requires fewer evaluations than genetic algorithms to find the Pareto front, therefore they are well suited for the stochastic optimization problems." - ], - "id": "efe12d81968cda69" + ] }, { - "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, + "execution_count": 5, + "id": "af98e2db55f89153", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T08:56:05.620871Z", + "iopub.status.busy": "2026-10-09T08:56:05.620871Z", + "iopub.status.idle": "2026-10-09T08:56:16.225940Z", + "shell.execute_reply": "2026-10-09T08:56:16.225940Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:08,036 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (20 real unique, 20 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:08,136 sb_arch_opt.sbo : Infill: 4 new (eval 20 real unique, 20 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:09,093 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (24 real unique, 24 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:09,201 sb_arch_opt.sbo : Infill: 4 new (eval 24 real unique, 24 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:10,176 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (28 real unique, 28 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:10,363 sb_arch_opt.sbo : Infill: 4 new (eval 28 real unique, 28 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:11,325 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (32 real unique, 32 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:11,473 sb_arch_opt.sbo : Infill: 4 new (eval 32 real unique, 32 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:12,400 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (36 real unique, 36 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:12,662 sb_arch_opt.sbo : Infill: 4 new (eval 36 real unique, 36 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:13,552 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (40 real unique, 40 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:13,646 sb_arch_opt.sbo : Infill: 4 new (eval 40 real unique, 40 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:14,594 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (44 real unique, 44 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:14,726 sb_arch_opt.sbo : Infill: 4 new (eval 44 real unique, 44 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:15,655 sb_arch_opt.sbo : Surrogate infill gen 10 @ 1000 points evaluated (48 real unique, 48 eval)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 2026-10-09 10:56:16,063 sb_arch_opt.sbo : Infill: 4 new (eval 48 real unique, 48 eval)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from sb_arch_opt.algo.arch_sbo.api import get_arch_sbo_gp\n", "\n", @@ -183,17 +382,31 @@ "plot(pf_deterministic, result_nsga2.opt.get('F'), result_sbo.opt.get('F'),\n", " labels=['Deterministic Pareto front', 'NSGA2 robust (2000 design points)',\n", " 'SBO robust (50 design points)'])" - ], - "id": "68b1694f096c0818" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "SBO reaches the same robust Pareto front as NSGA2 using 40 times fewer design points. Given that for each design points 12 evaluations are performed to propagate uncertainty, the computational budget savings are tremendous compared with NSGA-2 (overall 480 less evaluations).", - "id": "d4f0ff16942cc3c4" + "id": "1d4414e5f0c9fc9f", + "metadata": {}, + "source": [ + "SBO reaches the same robust Pareto front as NSGA2 using 40 times fewer design points. Given that for each design points 12 evaluations are performed to propagate uncertainty, the computational budget savings are tremendous compared with NSGA-2 (overall 480 less evaluations)." + ] } ], - "metadata": {}, + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.14" + } + }, "nbformat": 4, "nbformat_minor": 5 } diff --git a/sb_arch_opt/uncertainty.py b/sb_arch_opt/uncertainty.py index aaa18e0..273c893 100644 --- a/sb_arch_opt/uncertainty.py +++ b/sb_arch_opt/uncertainty.py @@ -142,9 +142,10 @@ class StochasticOutput: :param dist: the output distribution for the specific objective or constraint. """ - def __init__(self, dist: ot.Distribution, method_results=None): + def __init__(self, dist: ot.Distribution, samples: np.ndarray, method_results=None): check_dependency() self.dist = dist + self.samples = samples self.method_results = method_results @staticmethod @@ -168,10 +169,11 @@ def from_output_samples(cls, output_samples: ot.Sample, method_results=None) -> a float value is returned to represent deterministic output. If any sample is nan, np.nan is returned. """ + values = np.asarray(output_samples, dtype=float).ravel() dist = cls.build_distribution(output_samples) if isinstance(dist, float): return dist - return cls(dist=dist, method_results=method_results) + return cls(dist=dist, samples=values, method_results=method_results) @property def mean(self) -> float: @@ -259,14 +261,16 @@ class Quantile(Scalarization): """ - def __init__(self, q: float = 0.95): + def __init__(self, q: float = 0.95, direction: int =-1): super().__init__() if not 0. <= q <= 1.: raise ValueError(f'Quantile should be between 0 and 1: {q}') self.q = q + self.direction = direction def scalarize(self, output: StochasticOutput) -> float: - return float(output.quantile(self.q)) + q = self.q if self.direction == -1 else 1 - self.q + return float(output.quantile(q)) def __repr__(self): return f"Quantile with q = {self.q}"