pyfemtet 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

pyfemtet/opt/interface/_femtet.py

@@ -49,6 +49,10 @@ def _post_activate_message(hwnd):
     win32gui.PostMessage(hwnd, win32con.WM_ACTIVATE, win32con.WA_ACTIVE, 0)
 
 
+class FailedToPostProcess(Exception):
+    pass
+
+
 class FemtetInterface(FEMInterface):
     """Control Femtet from optimizer.
 
@@ -181,9 +185,7 @@ class FemtetInterface(FEMInterface):
         )
 
     def __del__(self):
-        _set_autosave_enabled(self._original_autosave_enabled)
-        if self.quit_when_destruct:
-            self.quit()
+        self.quit()
         # CoUninitialize()  # Win32 exception occurred releasing IUnknown at 0x0000022427692748
 
     def _connect_new_femtet(self):
@@ -726,7 +728,8 @@ class FemtetInterface(FEMInterface):
 
         _set_autosave_enabled(self._original_autosave_enabled)
 
-        _exit_or_force_terminate(timeout=timeout, Femtet=self.Femtet, force=True)
+        if self.quit_when_destruct:
+            _exit_or_force_terminate(timeout=timeout, Femtet=self.Femtet, force=True)
 
     def _setup_before_parallel(self, client):
         client.upload_file(
@@ -738,8 +741,15 @@ class FemtetInterface(FEMInterface):
         return _version(Femtet=self.Femtet)
 
     def _create_postprocess_args(self):
-        file_content = self._create_result_file_content()
-        jpg_content = self._create_jpg_content()
+        try:
+            file_content = self._create_result_file_content()
+        except FailedToPostProcess:
+            file_content = None
+
+        try:
+            jpg_content = self._create_jpg_content()
+        except FailedToPostProcess:
+            jpg_content = None
 
         out = dict(
             original_femprj_path=self.original_femprj_path,
@@ -787,7 +797,7 @@ class FemtetInterface(FEMInterface):
                 fun=self.Femtet.SavePDT,
                 args=(pdt_path, True),
                 return_value_if_failed=False,
-                if_error=SolveError,
+                if_error=FailedToPostProcess,
                 error_message=Msg.ERR_FAILED_TO_SAVE_PDT,
                 is_Gaudi_method=False,
             )
@@ -815,10 +825,10 @@ class FemtetInterface(FEMInterface):
         self.Femtet.RedrawMode = True  # 逐一の描画をオン
 
         if not succeed:
-            raise Exception(Msg.ERR_FAILED_TO_SAVE_JPG)
+            raise FailedToPostProcess(Msg.ERR_FAILED_TO_SAVE_JPG)
 
         if not os.path.exists(jpg_path):
-            raise Exception(Msg.ERR_JPG_NOT_FOUND)
+            raise FailedToPostProcess(Msg.ERR_JPG_NOT_FOUND)
 
         with open(jpg_path, 'rb') as f:
             content = f.read()

pyfemtet/opt/interface/_surrogate/__init__.py

@@ -0,0 +1,5 @@
+from pyfemtet.opt.interface._surrogate._singletaskgp import PoFBoTorchInterface
+
+__all__ = [
+    PoFBoTorchInterface,
+]

pyfemtet/opt/interface/_surrogate/_base.py

@@ -0,0 +1,85 @@
+from typing import Optional, List, Any
+from abc import ABC
+
+import numpy as np
+import pandas as pd
+
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt._femopt_core import History, Objective
+from pyfemtet.opt.interface._base import FEMInterface
+from pyfemtet.opt.optimizer._base import AbstractOptimizer
+
+logger = get_module_logger('opt.interface', __name__)
+
+
+class SurrogateModelInterfaceBase(FEMInterface, ABC):
+    def __init__(
+            self,
+            history_path: str = None,
+            history: History = None,
+    ):
+
+        self.history: History
+        self.model: Any
+        self.prm: dict[str, float] = dict()
+        self.obj: dict[str, float] = dict()
+        self.df_prm: pd.DataFrame
+        self.df_obj: pd.DataFrame
+
+        # history_path が与えられた場合、history をコンストラクトする
+        if history_path is not None:
+            history = History(history_path=history_path)
+
+        # history が与えられるかコンストラクトされている場合
+        if history is not None:
+            # 学習データを準備する
+            df_prm = history.get_df()[history.prm_names]
+            df_obj = history.get_df()[history.obj_names]
+
+            # obj の名前を作る
+            for obj_name in history.obj_names:
+                self.obj[obj_name] = np.nan
+
+            # prm の名前を作る
+            for prm_name in history.prm_names:
+                self.prm[prm_name] = np.nan
+
+            self.history = history
+
+        # history から作らない場合、引数チェック
+        else:
+            # assert len(train_x) == len(train_y)
+            raise NotImplementedError
+
+        self.df_prm = df_prm
+        self.df_obj = df_obj
+
+        FEMInterface.__init__(
+            self,
+            history=history,  # コンストラクト済み history を渡せば並列計算時も何もしなくてよい
+        )
+
+    def filter_feasible(self, x: np.ndarray, y: np.ndarray, return_feasibility=False):
+        feasible_idx = np.where(~np.isnan(y.sum(axis=1)))
+        if return_feasibility:
+            # calculated or not
+            y = np.zeros_like(y)
+            y[feasible_idx] = 1.
+            # satisfy weak feasibility or not
+            infeasible_idx = np.where(~self.history.get_df()['feasible'].values)
+            y[infeasible_idx] = .0
+            return x, y.reshape((-1, 1))
+        else:
+            return x[feasible_idx], y[feasible_idx]
+
+    def _setup_after_parallel(self, *args, **kwargs):
+
+        opt: AbstractOptimizer = kwargs['opt']
+        obj: Objective
+        for obj_name, obj in opt.objectives.items():
+            obj.fun = lambda: self.obj[obj_name]
+
+    def update_parameter(self, parameters: pd.DataFrame, with_warning=False) -> Optional[List[str]]:
+        for i, row in parameters.iterrows():
+            name, value = row['name'], row['value']
+            self.prm[name] = value

pyfemtet/opt/interface/_surrogate/_chaospy.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pandas as pd
+
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
+from pyfemtet.opt.prediction.polynomial_expansion import PolynomialExpansionModel
+
+
+logger = get_module_logger('opt.interface', __name__)
+
+
+class PolynomialChaosInterface(SurrogateModelInterfaceBase):
+
+    model: PolynomialExpansionModel  # surrogate_func_expansion
+
+    def train(self):
+        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values)
+        assert len(x) > 0, 'No feasible results in training data.'
+        self.model.fit(x, y)
+
+    def _setup_after_parallel(self, *args, **kwargs):
+
+        # # update objectives
+        # SurrogateModelInterfaceBase._setup_after_parallel(
+        #     self, *args, **kwargs
+        # )
+
+        # train model
+        self.model = PolynomialExpansionModel()
+        self.model.set_bounds_from_history(self.history)
+        self.train()
+
+    def update(self, parameters: pd.DataFrame) -> None:
+        # self.prm 更新
+        SurrogateModelInterfaceBase.update_parameter(
+            self, parameters
+        )
+
+        # history.prm_name 順に並べ替え
+        x = np.array([self.prm[k] for k in self.history.prm_names])
+
+        # prediction
+        dist_mean, _ = self.model.predict(x)
+
+        # 目的関数の更新
+        self.obj = {obj_name: value for obj_name, value in zip(self.history.obj_names, dist_mean)}
+
+
+if __name__ == '__main__':
+    import os
+    from pyfemtet.opt._femopt_core import History
+
+    os.chdir(os.path.dirname(__file__))
+
+    history = History(history_path='sample.csv')
+    fem = PolynomialChaosInterface(history=history)
+
+    import pandas as pd
+    df = history.get_df()
+    parameters = pd.DataFrame(
+        dict(
+            name=history.prm_names,
+            value=[1. for _ in history.prm_names]
+        )
+    )
+
+    fem._setup_after_parallel()
+
+    fem.update(
+        parameters
+    )

pyfemtet/opt/interface/_surrogate/_singletaskgp.py

@@ -0,0 +1,70 @@
+import numpy as np
+import pandas as pd
+from scipy.stats.distributions import norm
+
+from pyfemtet.core import SolveError
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
+from pyfemtet.opt.prediction.single_task_gp import SingleTaskGPModel
+
+from pyfemtet._message.messages import Message as Msg
+
+
+logger = get_module_logger('opt.interface', __name__)
+
+
+class PoFBoTorchInterface(SurrogateModelInterfaceBase):
+    model_f: SingleTaskGPModel
+    model: SingleTaskGPModel
+    threshold = 0.5
+
+    def train(self):
+        # df そのまま用いて training する
+        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values)
+        assert len(x) > 0, 'No feasible results in training data.'
+        self.model.fit(x, y)
+
+    def train_f(self):
+        # df そのまま用いて training する
+        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values, return_feasibility=True)
+        if y.min() == 1:
+            self.model_f.predict = lambda *args, **kwargs: (1., 0.001)
+        self.model_f.fit(x, y)
+
+    def _setup_after_parallel(self, *args, **kwargs):
+
+        # update objectives
+        SurrogateModelInterfaceBase._setup_after_parallel(
+            self, *args, **kwargs
+        )
+
+        # model training
+        self.model = SingleTaskGPModel()
+        self.model.set_bounds_from_history(self.history)
+        self.train()
+
+        # model_f training
+        self.model_f = SingleTaskGPModel(is_noise_free=False)
+        self.model_f.set_bounds_from_history(self.history)
+        self.train_f()
+
+    def update(self, parameters: pd.DataFrame) -> None:
+        # self.prm 更新
+        SurrogateModelInterfaceBase.update_parameter(
+            self, parameters
+        )
+
+        # history.prm_name 順に並べ替え
+        x = np.array([self.prm[k] for k in self.history.prm_names])
+
+        # feasibility の計算
+        mean_f, std_f = self.model_f.predict(np.array([x]))
+        pof = 1. - norm.cdf(self.threshold, loc=mean_f, scale=std_f)
+        if pof < self.threshold:
+            raise SolveError(Msg.INFO_POF_IS_LESS_THAN_THRESHOLD)
+
+        # 実際の計算(mean は history.obj_names 順)
+        mean, _ = self.model.predict(np.array([x]))
+
+        # 目的関数の更新
+        self.obj = {obj_name: value for obj_name, value in zip(self.history.obj_names, mean)}

pyfemtet/opt/optimizer/_base.py

@@ -155,12 +155,18 @@ class AbstractOptimizer(ABC):
         """Setup before parallel processes are launched."""
         pass
 
+    def generate_infeasible_result(self):
+        y = np.full_like(np.zeros(len(self.objectives)), np.nan)
+        c = np.full_like(np.zeros(len(self.constraints)), np.nan)
+        return y, y, c
+
     # ===== calc =====
-    def f(self, x: np.ndarray) -> list[np.ndarray]:
+    def f(self, x: np.ndarray, _record_infeasible=False) -> list[np.ndarray]:
         """Calculate objectives and constraints.
 
         Args:
             x (np.ndarray): Optimization parameters.
+            _record_infeasible (bool): If True, skip fem.update() and record self.generate_invalid_results().
 
         Returns:
             list[np.ndarray]:
@@ -178,27 +184,31 @@ class AbstractOptimizer(ABC):
         self.set_parameter_values(x)
         logger.info(f'input: {x}')
 
-        # FEM の更新
-        try:
-            logger.info(f'Solving FEM...')
-            df_to_fem = self.variables.get_variables(
-                format='df',
-                filter_pass_to_fem=True
-            )
-            self.fem.update(df_to_fem)
+        if not _record_infeasible:
+            # FEM の更新
+            try:
+                logger.info(f'Solving FEM...')
+                df_to_fem = self.variables.get_variables(
+                    format='df',
+                    filter_pass_to_fem=True
+                )
+                self.fem.update(df_to_fem)
 
-        except Exception as e:
-            logger.info(f'{type(e).__name__} : {e}')
-            logger.info(Msg.INFO_EXCEPTION_DURING_FEM_ANALYSIS)
-            logger.info(x)
-            raise e  # may be just a ModelError, etc. Handling them in Concrete classes.
+            except Exception as e:
+                logger.info(f'{type(e).__name__} : {e}')
+                logger.info(Msg.INFO_EXCEPTION_DURING_FEM_ANALYSIS)
+                logger.info(x)
+                raise e  # may be just a ModelError, etc. Handling them in Concrete classes.
 
-        # y, _y, c の更新
-        y = [obj.calc(self.fem) for obj in self.objectives.values()]
+            # y, _y, c の更新
+            y = [obj.calc(self.fem) for obj in self.objectives.values()]
 
-        _y = [obj.convert(value) for obj, value in zip(self.objectives.values(), y)]
+            _y = [obj.convert(value) for obj, value in zip(self.objectives.values(), y)]
 
-        c = [cns.calc(self.fem) for cns in self.constraints.values()]
+            c = [cns.calc(self.fem) for cns in self.constraints.values()]
+
+        else:
+            y, _y, c = self.generate_infeasible_result()
 
         # register to history
         df_to_opt = self.variables.get_variables(

pyfemtet/opt/optimizer/_optuna/_optuna.py

@@ -4,6 +4,7 @@ from typing import Iterable
 # built-in
 import os
 import inspect
+import gc
 
 # 3rd-party
 import optuna
@@ -92,10 +93,7 @@ class OptunaOptimizer(AbstractOptimizer):
     def _objective(self, trial):
 
         logger.info('')
-        if self._retry_counter == 0:
-            logger.info(f'===== trial {1 + len(self.history.get_df())} start =====')
-        else:
-            logger.info(f'===== trial {1 + len(self.history.get_df())} (retry {self._retry_counter}) start =====')
+        logger.info(f'===== trial {1 + len(self.history.get_df())} ({len(self.history.get_df(valid_only=True))} succeeded trials) start =====')
 
         # 中断の確認 (FAIL loop に陥る対策)
         if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
@@ -124,6 +122,7 @@ class OptunaOptimizer(AbstractOptimizer):
         # fem 経由で変数を取得して constraint を計算する時のためにアップデート
         df_fem = self.variables.get_variables(format='df', filter_pass_to_fem=True)
         self.fem.update_parameter(df_fem)
+        x = self.variables.get_variables(format='values', filter_parameter=True)
 
         # strict 拘束
         strict_constraints = [cns for cns in self.constraints.values() if cns.strict]
@@ -140,10 +139,11 @@ class OptunaOptimizer(AbstractOptimizer):
                 logger.info(f'Constraint: {cns.name}')
                 logger.info(self.variables.get_variables('dict', filter_parameter=True))
                 self._retry_counter += 1
+                self.message = f'Failed to calculate objectives because of the constraint violation: {cns.name}'
+                self.f(x, _record_infeasible=True)
                 raise optuna.TrialPruned()  # set TrialState PRUNED because FAIL causes similar candidate loop.
 
         # 計算
-        x = self.variables.get_variables(format='values', filter_parameter=True)
         try:
             _, _y, c = self.f(x)  # f の中で info は出している
         except (ModelError, MeshError, SolveError) as e:
@@ -162,6 +162,8 @@ class OptunaOptimizer(AbstractOptimizer):
                            'or analysis.')
 
             self._retry_counter += 1
+            self.message = f'Failed to calculate objectives because of the parameter broke the FEM model.'
+            self.f(x, _record_infeasible=True)
             raise optuna.TrialPruned()  # set TrialState PRUNED because FAIL causes similar candidate loop.
 
         # 拘束 attr の更新
@@ -284,8 +286,19 @@ class OptunaOptimizer(AbstractOptimizer):
             from optuna.samplers import TPESampler
             if issubclass(self.sampler_class, TPESampler):
 
-                if os.path.exists(self._temporary_storage_path):
-                    os.remove(self._temporary_storage_path)
+                import re
+                pattern = r'_\d+$'
+
+                while os.path.exists(self._temporary_storage_path):
+                    name, ext = os.path.splitext(self._temporary_storage_path)
+
+                    if bool(re.search(pattern, name)):
+                        base = '_'.join(name.split('_')[:-1])
+                        n = int(name.split('_')[-1])
+                        self._temporary_storage_path = name + '_' + str(n+1) + ext
+
+                    else:
+                        self._temporary_storage_path = name + '_2' + ext
 
                 self._temporary_storage = optuna.integration.dask.DaskStorage(
                     f'sqlite:///{self._temporary_storage_path}',
@@ -403,7 +416,6 @@ class OptunaOptimizer(AbstractOptimizer):
                 self._temporary_storage.remove_session()
                 del self._temporary_storage
                 del _study
-                import gc
                 gc.collect()
                 if os.path.exists(self._temporary_storage_path):
                     os.remove(self._temporary_storage_path)

pyfemtet/opt/optimizer/_optuna/_pof_botorch.py

@@ -169,6 +169,21 @@ def symlog(x):
     )
 
 
+def get_minimum_YVar_and_standardizer(Y: torch.Tensor):
+    standardizer = Standardize(m=Y.shape[-1])
+    if _get_use_fixed_noise():
+        import gpytorch
+        min_noise = gpytorch.settings.min_fixed_noise.value(Y.dtype)
+
+        standardizer.forward(Y)  # require to un-transform
+        _, YVar = standardizer.untransform(Y, min_noise * torch.ones_like(Y))
+
+    else:
+        YVar = None
+
+    return YVar, standardizer
+
+
 # ベースとなる獲得関数クラスに pof 係数を追加したクラスを作成する関数
 def acqf_patch_factory(acqf_class, pof_config=None):
     """ベース acqf クラスに pof 係数の計算を追加したクラスを作成します。
@@ -394,11 +409,13 @@ def logei_candidates_func(
 
     train_x = normalize(train_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -540,11 +557,13 @@ def qei_candidates_func(
     if pending_x is not None:
         pending_x = normalize(pending_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -641,11 +660,13 @@ def qnei_candidates_func(
     if pending_x is not None:
         pending_x = normalize(pending_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -747,11 +768,13 @@ def qehvi_candidates_func(
     if pending_x is not None:
         pending_x = normalize(pending_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -850,11 +873,13 @@ def ehvi_candidates_func(
     train_y = train_obj
     train_x = normalize(train_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -962,11 +987,13 @@ def qnehvi_candidates_func(
     if pending_x is not None:
         pending_x = normalize(pending_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -1083,11 +1110,13 @@ def qparego_candidates_func(
     if pending_x is not None:
         pending_x = normalize(pending_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -1184,11 +1213,13 @@ def qkg_candidates_func(
     if pending_x is not None:
         pending_x = normalize(pending_x, bounds=bounds)
 
+    train_yvar, standardizer = get_minimum_YVar_and_standardizer(train_y)
+
     model = SingleTaskGP(
         train_x,
         train_y,
-        train_Yvar=1e-4*torch.ones_like(train_y) if _get_use_fixed_noise() else None,
-        outcome_transform=Standardize(m=train_y.size(-1))
+        train_Yvar=train_yvar,
+        outcome_transform=standardizer,
     )
     mll = ExactMarginalLogLikelihood(model.likelihood, model)
     fit_gpytorch_mll(mll)
@@ -1286,7 +1317,7 @@ def qhvkg_candidates_func(
         SingleTaskGP(
             train_x,
             train_y[..., [i]],
-            train_Yvar=1e-4*torch.ones_like(train_y[..., [i]]) if _get_use_fixed_noise() else None,
+            train_Yvar=get_minimum_YVar_and_standardizer(train_y[..., [i]])[0],
             outcome_transform=Standardize(m=1)
         )
         for i in range(train_y.shape[-1])
@@ -1763,7 +1794,18 @@ class PoFBoTorchSampler(BaseSampler):
             for trial_idx, trial in enumerate(trials):
                 params[trial_idx] = trans.transform(trial.params)
                 if trial.state == TrialState.COMPLETE:
-                    values[trial_idx, 0] = 1.  # feasible
+                    # complete, but infeasible (in case of weak constraint)
+                    if 'constraints' in trial.user_attrs.keys():
+                        cns = trial.user_attrs['constraints']
+                        if cns is None:
+                            values[trial_idx, 0] = 1.  # feasible (or should RuntimeError)
+                        else:
+                            if numpy.array(cns).max() > 0:
+                                values[trial_idx, 0] = 1.  # feasible
+                            else:
+                                values[trial_idx, 0] = 1.  # feasible
+                    else:
+                        values[trial_idx, 0] = 1.  # feasible
                 elif trial.state == TrialState.PRUNED:
                     values[trial_idx, 0] = 0.  # infeasible
                 else:

pyfemtet/opt/prediction/_base.py

@@ -32,6 +32,14 @@ class PyFemtetPredictionModel:
     def __init__(self, history: History, df: pd.DataFrame, MetaModel: type):
         assert issubclass(MetaModel, PredictionModelBase)
         self.meta_model: PredictionModelBase = MetaModel()
+
+        from pyfemtet.opt.prediction.single_task_gp import SingleTaskGPModel
+        if isinstance(self.meta_model, SingleTaskGPModel):
+            self.meta_model.set_bounds_from_history(
+                history,
+                df,
+            )
+
         self.obj_names = history.obj_names
         self.prm_names = history.prm_names
         self.df = df