pyfemtet 0.4.20__py3-none-any.whl → 0.4.23__py3-none-any.whl

pyfemtet/opt/interface/_femtet.py

@@ -215,6 +215,24 @@ class FemtetInterface(FEMInterface):
         if self.Femtet is None:
             raise RuntimeError(Msg.ERR_FEMTET_CONNECTION_FAILED)
 
+    def _check_gaudi_accessible(self) -> bool:
+        try:
+            _ = self.Femtet.Gaudi
+        except com_error:
+            # モデルが開かれていないかFemtetが起動していない
+            return False
+        return True
+
+    # noinspection PyMethodMayBeStatic
+    def _construct_femtet_api(self, string):  # static にしてはいけない
+        if isinstance(string, str):
+            if string.startswith('self.'):
+                return eval(string)
+            else:
+                return eval('self.' + string)
+        else:
+            return string  # Callable
+
     def _call_femtet_api(
             self,
             fun,
@@ -232,7 +250,7 @@ class FemtetInterface(FEMInterface):
 
         Parameters
         ----------
-        fun : Callable
+        fun : Callable or str
             Femtet API
         return_value_if_failed : Any
             API が失敗した時の戻り値
@@ -271,36 +289,62 @@ class FemtetInterface(FEMInterface):
         # 1. 結果に関わらず戻り値が None で API 実行時に com_error を送出する
         # 2. API 実行時に成功失敗を示す戻り値を返し、ShowLastError で例外にアクセスできる状態になる
 
+        # 実行する API をデバッグ出力
+        if isinstance(fun, str):
+            logger.debug(' ' * print_indent + f'Femtet API:{fun}, args:{args}, kwargs:{kwargs}')
+        else:
+            logger.debug(' ' * print_indent + f'Femtet API:{fun.__name__}, args:{args}, kwargs:{kwargs}')
+
         # Gaudi コマンドなら Gaudi.Activate する
-        logger.debug(' ' * print_indent + f'Femtet API:{fun.__name__}, args:{args}, kwargs:{kwargs}')
         if is_Gaudi_method:  # Optimizer は Gogh に触らないので全部にこれをつけてもいい気がする
             try:
-                self._call_femtet_api(
-                    self.Femtet.Gaudi.Activate,
-                    False,  # None 以外なら何でもいい
-                    Exception,
-                    'Gaudi のオープンに失敗しました',
-                    print_indent=print_indent + 1
-                )
+                # まず Gaudi にアクセスできるか
+                gaudi_accessible = self._check_gaudi_accessible()
+                if gaudi_accessible:
+                    # Gaudi にアクセスできるなら Gaudi を Activate する
+                    fun = self._construct_femtet_api(fun)  # (str) -> Callable
+                    if fun.__name__ != 'Activate':
+                        # 再帰ループにならないように
+                        self._call_femtet_api(
+                            self.Femtet.Gaudi.Activate,
+                            False,  # None 以外なら何でもいい
+                            Exception,
+                            'Gaudi のオープンに失敗しました',
+                            print_indent=print_indent + 1
+                        )
+
+                else:
+                    # Gaudi にアクセスできないならば次の API 実行でエラーになる
+                    pass
+
             except com_error:
-                # Gaudi へのアクセスだけで com_error が生じうる
-                # そういう場合は次の API 実行で間違いなくエラーになるので放っておく
                 pass
 
         # API を実行
         try:
+            # gaudi のメソッドかどうかにかかわらず、gaudi へのアクセスでエラーが出るか
+            if not self._check_gaudi_accessible():
+                raise com_error
+
+            # gaudi_accessible なので関数が何であろうが安全にアクセスはできる
+            if isinstance(fun, str):
+                fun = self._construct_femtet_api(fun)  # (str) -> Callable
+
             # 解析結果を開いた状態で Gaudi.Activate して ReExecute する場合、ReExecute の前後にアクティブ化イベントが必要
             # さらに、プロジェクトツリーが開いていないとアクティブ化イベントも意味がないらしい。
             if fun.__name__ == 'ReExecute':
                 if self.open_result_with_gui or self.parametric_output_indexes_use_as_objective:
                     post_activate_message(self.Femtet.hWnd)
+                # API を実行
                 returns = fun(*args, **kwargs)  # can raise pywintypes.error
                 if self.open_result_with_gui or self.parametric_output_indexes_use_as_objective:
                     post_activate_message(self.Femtet.hWnd)
             else:
                 returns = fun(*args, **kwargs)
+
+        # API の実行に失敗
         except (com_error, error):
-            # パターン 2 エラーが生じたことは確定なのでエラーが起こるよう returns を作る
+            # 後続の処理でエラー判定されるように returns を作る
             # com_error ではなく error の場合はおそらく Femtet が落ちている
             if ret_for_check_idx is None:
                 returns = return_value_if_failed
@@ -361,7 +405,7 @@ class FemtetInterface(FEMInterface):
 
     def femtet_is_alive(self) -> bool:
         """Returns connected femtet process is existing or not."""
-        return _get_pid(self.Femtet.hWnd) > 0
+        return _get_pid(self.Femtet.hWnd) > 0  # hWnd の値はすでに Femtet が終了している場合は 0
 
     def open(self, femprj_path: str, model_name: str or None = None) -> None:
         """Open specific analysis model with connected Femtet."""
@@ -479,7 +523,7 @@ class FemtetInterface(FEMInterface):
         # 変数更新のための処理
         sleep(0.1)  # Gaudi がおかしくなる時がある対策
         self._call_femtet_api(
-            self.Femtet.Gaudi.Activate,
+            'self.Femtet.Gaudi.Activate',
             True,  # 戻り値を持たないのでここは無意味で None 以外なら何でもいい
             Exception,  # 生きてるのに開けない場合
             error_message=Msg.NO_ANALYSIS_MODEL_IS_OPEN,
@@ -553,7 +597,7 @@ class FemtetInterface(FEMInterface):
 
         # 設計変数に従ってモデルを再構築
         self._call_femtet_api(
-            self.Femtet.Gaudi.ReExecute,
+            'self.Femtet.Gaudi.ReExecute',
             False,
             ModelError,  # 生きてるのに失敗した場合
             error_message=Msg.ERR_RE_EXECUTE_MODEL_FAILED,
@@ -576,7 +620,7 @@ class FemtetInterface(FEMInterface):
         """Execute FEM analysis."""
         # # メッシュを切る
         self._call_femtet_api(
-            self.Femtet.Gaudi.Mesh,
+            'self.Femtet.Gaudi.Mesh',
             0,
             MeshError,
             Msg.ERR_MODEL_MESH_FAILED,
@@ -630,6 +674,11 @@ class FemtetInterface(FEMInterface):
     def quit(self, timeout=1, force=True):
         """Force to terminate connected Femtet."""
         major, minor, bugfix = 2024, 0, 1
+
+        # すでに終了しているならば何もしない
+        if not self.femtet_is_alive():
+            return
+
         if self._version() >= _version(major, minor, bugfix):
             # gracefully termination method without save project available from 2024.0.1
             try:
@@ -715,16 +764,20 @@ class FemtetInterface(FEMInterface):
             # save to worker space
             result_dir = self.femprj_path.replace('.femprj', '.Results')
             pdt_path = os.path.join(result_dir, self.model_name + '.pdt')
-            succeed = self.Femtet.SavePDT(pdt_path, True)
 
-            # convert .pdt to ByteIO
-            if succeed:
-                with open(pdt_path, 'rb') as f:
-                    content = f.read()
-                return content
+            self._call_femtet_api(
+                fun=self.Femtet.SavePDT,
+                args=(pdt_path, True),
+                return_value_if_failed=False,
+                if_error=SolveError,
+                error_message=Msg.ERR_FAILED_TO_SAVE_PDT,
+                is_Gaudi_method=False,
+            )
 
-            else:
-                raise Exception(Msg.ERR_FAILED_TO_SAVE_PDT)
+            # convert .pdt to ByteIO and return it
+            with open(pdt_path, 'rb') as f:
+                content = f.read()
+            return content
 
         else:
             return None

pyfemtet/opt/opt/_base.py

@@ -1,5 +1,6 @@
 # typing
 from abc import ABC, abstractmethod
+from typing import Optional
 
 # built-in
 import traceback
@@ -13,6 +14,7 @@ import pandas as pd
 from pyfemtet.opt.interface import FemtetInterface
 from pyfemtet.opt._femopt_core import OptimizationStatus
 from pyfemtet.message import Msg
+from pyfemtet.opt.parameter import ExpressionEvaluator
 
 # logger
 import logging
@@ -134,6 +136,7 @@ class AbstractOptimizer(ABC):
         self.fem_class = None
         self.fem_kwargs = dict()
         self.parameters: pd.DataFrame = pd.DataFrame()
+        self.variables: ExpressionEvaluator = ExpressionEvaluator()
         self.objectives: dict = dict()
         self.constraints: dict = dict()
         self.entire_status = None  # actor
@@ -145,7 +148,7 @@ class AbstractOptimizer(ABC):
         self.n_trials = None
         self.is_cluster = False
         self.subprocess_idx = None
-        self._is_error_exit = False
+        self._exception = None
         self.method_checker: OptimizationMethodChecker = OptimizationMethodChecker(self)
 
     def f(self, x):
@@ -153,14 +156,22 @@ class AbstractOptimizer(ABC):
         # interruption の実装は具象クラスに任せる
 
         # x の更新
-        self.parameters['value'] = x
+        prm_names = self.variables.get_parameter_names()
+        for name, value in zip(prm_names, x):
+            self.variables.variables[name].value = value
+
         logger.info('---------------------')
         logger.info(f'input: {x}')
 
         # FEM の更新
         logger.debug('fem.update() start')
         try:
-            self.fem.update(self.parameters)
+            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)
@@ -178,8 +189,14 @@ class AbstractOptimizer(ABC):
         c = [cns.calc(self.fem) for cns in self.constraints.values()]
 
         logger.debug('history.record start')
+
+        df_to_opt = self.variables.get_variables(
+            format='df',
+            filter_parameter=True,
+        )
+
         self.history.record(
-            self.parameters,
+            df_to_opt,
             self.objectives,
             self.constraints,
             y,
@@ -220,17 +237,7 @@ class AbstractOptimizer(ABC):
             ValueError: If an invalid format is provided.
 
         """
-        if format == 'df':
-            return self.parameters
-        elif format == 'values' or format == 'value':
-            return self.parameters.value.values
-        elif format == 'dict':
-            ret = {}
-            for i, row in self.parameters.iterrows():
-                ret[row['name']] = row.value
-            return ret
-        else:
-            raise ValueError(f'get_parameter() got invalid format: {format}')
+        return self.variables.get_variables(format=format)
 
     def _check_interruption(self):
         """"""
@@ -253,7 +260,7 @@ class AbstractOptimizer(ABC):
             worker_status_list,
             wait_setup,
             skip_set_fem=False,
-    ) -> bool:
+    ) -> Optional[Exception]:
 
         # 自分の worker_status の取得
         self.subprocess_idx = subprocess_idx
@@ -296,12 +303,12 @@ class AbstractOptimizer(ABC):
             logger.error("=================================")
             logger.error(f'{type(e).__name__}: {e}')
             traceback.print_exc()
-            self._is_error_exit = True
+            self._exception = e
             self.worker_status.set(OptimizationStatus.CRASHED)
         finally:
             self._finalize()
 
-        return self._is_error_exit
+        return self._exception
 
     @abstractmethod
     def run(self) -> None:

pyfemtet/opt/opt/_optuna.py

@@ -54,6 +54,7 @@ class OptunaOptimizer(AbstractOptimizer):
         self.additional_initial_parameter = []
         self.additional_initial_methods = add_init_method if hasattr(add_init_method, '__iter__') else [add_init_method]
         self.method_checker = OptunaMethodChecker(self)
+        self.parameter_constraints = []
 
     def _objective(self, trial):
 
@@ -63,19 +64,25 @@ class OptunaOptimizer(AbstractOptimizer):
             trial.study.stop()  # 現在実行中の trial を最後にする
             return None  # set TrialState FAIL
 
-        # candidate x
-        x = []
-        for i, row in self.parameters.iterrows():
-            v = trial.suggest_float(row['name'], row['lb'], row['ub'], step=row['step'])
-            x.append(v)
-        x = np.array(x).astype(float)
+        # candidate x and update parameters
+        for prm in self.variables.get_variables(format='raw', filter_parameter=True):
+            value = trial.suggest_float(
+                name=prm.name,
+                low=prm.lower_bound,
+                high=prm.upper_bound,
+                step=prm.step,
+            )
+            self.variables.variables[prm.name].value = value
+
+        # update expressions
+        self.variables.evaluate()
 
         # message の設定
         self.message = trial.user_attrs['message'] if 'message' in trial.user_attrs.keys() else ''
 
-        # fem や opt 経由で変数を取得して constraint を計算する時のためにアップデート
-        self.parameters['value'] = x
-        self.fem.update_parameter(self.parameters)
+        # fem 経由で変数を取得して constraint を計算する時のためにアップデート
+        df_fem = self.variables.get_variables(format='df', filter_pass_to_fem=True)
+        self.fem.update_parameter(df_fem)
 
         # strict 拘束
         strict_constraints = [cns for cns in self.constraints.values() if cns.strict]
@@ -89,10 +96,11 @@ class OptunaOptimizer(AbstractOptimizer):
             if not feasible:
                 logger.info(Msg.INFO_INFEASIBLE)
                 logger.info(f'Constraint: {cns.name}')
-                logger.info(self.get_parameter('dict'))
+                logger.info(self.variables.get_variables('dict', filter_parameter=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:
@@ -153,7 +161,7 @@ class OptunaOptimizer(AbstractOptimizer):
 
             # restart である場合、追加 N 回と見做す
             if self.history.is_restart:
-                n_existing_trials = len(self.history.actor_data)
+                n_existing_trials = len(self.history.get_df())
                 n_trials += n_existing_trials
 
             self.optimize_callbacks.append(MaxTrialsCallback(n_trials, states=(TrialState.COMPLETE,)))
@@ -175,7 +183,7 @@ class OptunaOptimizer(AbstractOptimizer):
             # 初期値の設定
             if len(self.study.trials) == 0:  # リスタートでなければ
                 # ユーザーの指定した初期値
-                params = self.get_parameter('dict')
+                params = self.variables.get_variables('dict', filter_parameter=True)
                 self.study.enqueue_trial(params, user_attrs={"message": "initial"})
 
                 # add_initial_parameter で追加された初期値
@@ -197,8 +205,8 @@ class OptunaOptimizer(AbstractOptimizer):
                     bounds = []
                     for i, row in self.parameters.iterrows():
                         names.append(row['name'])
-                        lb = row['lb']
-                        ub = row['ub']
+                        lb = row['lower_bound']
+                        ub = row['upper_bound']
                         bounds.append([lb, ub])
                     data = generate_lhs(bounds, seed=self.seed)
                     for datum in data:
@@ -266,9 +274,40 @@ class OptunaOptimizer(AbstractOptimizer):
             sampler=sampler,
         )
 
+        # monkey patch
+        if len(self.parameter_constraints) > 0:
+            assert isinstance(sampler, optuna.integration.BoTorchSampler), Msg.ERR_PARAMETER_CONSTRAINT_ONLY_BOTORCH
+
+            from pyfemtet.opt.opt._optuna_botorch_helper import OptunaBotorchWithParameterConstraintMonkeyPatch
+            mp = OptunaBotorchWithParameterConstraintMonkeyPatch(
+                study,
+                self,
+            )
+            for p_cns in self.parameter_constraints:
+                fun = p_cns['fun']
+                prm_args = p_cns['prm_args']
+                kwargs = p_cns['kwargs']
+                mp.add_nonlinear_constraint(fun, prm_args, kwargs)
+            mp.do_monkey_patch()
+
         # run
         study.optimize(
             self._objective,
             timeout=self.timeout,
             callbacks=self.optimize_callbacks,
         )
+
+    def add_parameter_constraints(
+            self,
+            fun,
+            prm_args=None,
+            kwargs=None
+    ):
+        kwargs = kwargs if kwargs is not None else {}
+        self.parameter_constraints.append(
+            dict(
+                fun=fun,
+                prm_args=prm_args,
+                kwargs=kwargs,
+            )
+        )

pyfemtet/opt/opt/_optuna_botorch_helper.py

@@ -0,0 +1,209 @@
+from typing import Optional, List, Tuple, Callable
+from functools import partial
+import inspect
+
+import numpy as np
+import optuna.study
+import torch
+from torch import Tensor
+from botorch.optim.initializers import gen_batch_initial_conditions
+from botorch.utils.transforms import unnormalize
+from optuna.study import Study
+from botorch.acquisition import AcquisitionFunction
+
+from pyfemtet.opt.opt import AbstractOptimizer
+from pyfemtet.opt.parameter import ExpressionEvaluator
+
+# module to monkey patch
+import optuna_integration
+
+
+# モンキーパッチを実行するため、optimize_acqf の引数を MonkyPatch クラスで定義し optuna に上書きされないようにするためのクラス
+class NonOverwritablePartial(partial):
+    def __call__(self, /, *args, **keywords):
+        stored_kwargs = self.keywords
+        keywords.update(stored_kwargs)
+        return self.func(*self.args, *args, **keywords)
+
+
+# prm_name を引数に取る関数を optimize_acqf の nonlinear_inequality_constraints に入れられる形に変換する関数
+class ConvertedConstraintFunction:
+    def __init__(self, fun, prm_args, kwargs, variables: ExpressionEvaluator, study: optuna.study.Study):
+        self.fun = fun
+        self.prm_args = prm_args
+        self.kwargs = kwargs
+        self.variables = variables
+        self.study = study
+
+        self.bounds = None
+        self.prm_name_seq = None
+
+        # fun の prm として使う引数が指定されていなければ fun の引数を取得
+        if self.prm_args is None:
+            signature = inspect.signature(fun)
+            prm_inputs = set([a.name for a in signature.parameters.values()])
+        else:
+            prm_inputs = set(self.prm_args)
+
+        # 引数の set から kwargs の key を削除
+        self.prm_arg_names = prm_inputs - set(kwargs.keys())
+
+        # 変な引数が残っていないか確認
+        assert all([(arg in variables.get_parameter_names()) for arg in self.prm_arg_names])
+
+    def __call__(self, x: Tensor or np.ndarray):
+        # x: all of normalized parameters whose sequence is sorted by optuna
+
+        if not isinstance(x, Tensor):
+            x = torch.tensor(np.array(x)).double()
+
+        x = unnormalize(x, self.bounds)
+
+        # fun で使うパラメータのみ value を取得
+        kwargs = self.kwargs
+        kwargs.update(
+            {k: v for k, v in zip(self.prm_name_seq, x) if k in self.prm_arg_names}
+        )
+
+        return self.fun(**kwargs)
+
+
+# 与えられた獲得関数に拘束を満たさない場合 0 を返すよう加工された獲得関数
+class AcqWithConstraint(AcquisitionFunction):
+
+    # noinspection PyAttributeOutsideInit
+    def set(self, _org_acq_function: AcquisitionFunction, nonlinear_constraints):
+        self._org_acq_function = _org_acq_function
+        self._nonlinear_constraints = nonlinear_constraints
+
+    def forward(self, X: Tensor) -> Tensor:
+        base = self._org_acq_function.forward(X)
+
+        is_feasible = all([cons(X[0][0]) > 0 for cons, _ in self._nonlinear_constraints])
+        if is_feasible:
+            return base
+        else:
+            # penalty = torch.Tensor(size=base.shape)
+            # penalty = torch.fill(penalty, -1e10)
+            # return base * penalty
+            return base * 0.
+
+
+def remove_infeasible(_ic_batch, nonlinear_constraints):
+    # infeasible なものを削除
+    remove_indices = []
+    for i, ic in enumerate(_ic_batch):  # ic: 1 x len(params) tensor
+        # cons: Callable[["Tensor"], "Tensor"]
+        is_feasible = all([cons(ic[0]) > 0 for cons, _ in nonlinear_constraints])
+        if not is_feasible:
+            # ic_batch[i] = torch.nan  # これで無視にならない
+            remove_indices.append(i)
+    for i in remove_indices[::-1]:
+        _ic_batch = torch.cat((_ic_batch[:i], _ic_batch[i + 1:]))
+    return _ic_batch
+
+
+class OptunaBotorchWithParameterConstraintMonkeyPatch:
+
+    def __init__(self, study: Study, opt: AbstractOptimizer):
+        self.num_restarts: int = 20
+        self.raw_samples_additional: int = 512
+        self.eta: float = 2.0
+        self.study = study
+        self.opt = opt
+        self.nonlinear_inequality_constraints = []
+        self.additional_kwargs = dict()
+        self.bounds = None
+        self.prm_name_seq = None
+
+    def add_nonlinear_constraint(self, fun, prm_args, kwargs):
+        f = ConvertedConstraintFunction(
+            fun,
+            prm_args,
+            kwargs,
+            self.opt.variables,
+            self.study,
+        )
+
+        # 初期化
+        self.nonlinear_inequality_constraints = self.nonlinear_inequality_constraints or []
+
+        # 自身に追加
+        self.nonlinear_inequality_constraints.append((f, True))
+
+        # optimize_acqf() に渡す引数に追加
+        self.additional_kwargs.update(
+            nonlinear_inequality_constraints=self.nonlinear_inequality_constraints
+        )
+
+    def _detect_prm_seq_if_needed(self):
+        # study から distribution の情報を復元する。
+        if self.bounds is None or self.prm_name_seq is None:
+            from optuna._transform import _transform_search_space
+            # sample_relative の後に呼ばれているから最後の trial は search_space を持つはず
+            search_space: dict = self.study.sampler.infer_relative_search_space(self.study, self.study.trials[-1])
+            self.bounds = _transform_search_space(search_space, False, False)[0].T
+            self.prm_name_seq = list(search_space.keys())
+
+            for cns in self.nonlinear_inequality_constraints:
+                cns[0].bounds = torch.tensor(self.bounds)
+                cns[0].prm_name_seq = self.prm_name_seq
+
+    def generate_initial_conditions(self, *args, **kwargs):
+        self._detect_prm_seq_if_needed()
+
+        # acqf_function を 上書きし、拘束を満たさないならば 0 を返すようにする
+        org_acq_function = kwargs['acq_function']
+        new_acqf = AcqWithConstraint(None)
+        new_acqf.set(org_acq_function, self.nonlinear_inequality_constraints)
+        kwargs['acq_function'] = new_acqf
+
+        # initial condition の提案 batch を作成
+        # ic: `num_restarts x q x d` tensor of initial conditions.
+        # q = 1, d = len(params)
+        ic_batch = gen_batch_initial_conditions(*args, **kwargs)
+
+        # 拘束を満たさないものを削除
+        ic_batch = remove_infeasible(ic_batch, self.nonlinear_inequality_constraints)
+
+        # 全部なくなっているならばランダムに生成
+        if len(ic_batch) == 0:
+            print('拘束を満たす組み合わせがなかったのでランダムサンプリングします')
+        while len(ic_batch) == 0:
+            size = ic_batch.shape
+            ic_batch = torch.rand(size=[100, *size[1:]])  # 正規化された変数の組合せ
+            ic_batch = remove_infeasible(ic_batch, self.nonlinear_inequality_constraints)
+
+        return ic_batch
+
+    def do_monkey_patch(self):
+        """optuna_integration.botorch には optimize_acqf に constraints を渡す方法が用意されていないので、モンキーパッチして渡す
+
+        モンキーパッチ自体は最適化実行前のどの時点で呼んでも機能するが、additional_kwargs の更新後に
+        モンキーパッチを呼ぶ必要があるのでコンストラクタにこの処理は入れない。
+        各 add_constraint に入れるのはいいかも。
+
+        """
+
+        # === reconstruct argument ``options`` for optimize_acqf ===
+        options = dict()  # initialize
+
+        # for nonlinear-constraint
+        options.update(dict(batch_limit=1))
+
+        # for gen_candidates_scipy()
+        # use COBYLA or SLSQP only.
+        options.update(dict(method='SLSQP'))
+
+        # make partial of optimize_acqf used in optuna_integration.botorch and replace to it.
+        original_fun = optuna_integration.botorch.optimize_acqf
+        overwritten_fun = NonOverwritablePartial(
+            original_fun,
+            q=1,  # for nonlinear constraints
+            options=options,
+            num_restarts=20,  # gen_batch_initial_conditions に渡すべきで、self.generate_initial_conditions に渡される変数。
+            raw_samples=512,  # gen_batch_initial_conditions に渡すべきで、self.generate_initial_conditions に渡される変数。
+            nonlinear_inequality_constraints=self.nonlinear_inequality_constraints,
+            ic_generator=self.generate_initial_conditions,
+        )
+        optuna_integration.botorch.optimize_acqf = overwritten_fun

pyfemtet/opt/opt/_scipy.py

@@ -114,7 +114,7 @@ class ScipyOptimizer(AbstractOptimizer):
         if 'bounds' not in self.minimize_kwargs.keys():
             bounds = []
             for i, row in self.parameters.iterrows():
-                lb, ub = row['lb'], row['ub']
+                lb, ub = row['lower_buond'], row['upper_bound']
                 if lb is None: lb = -np.inf
                 if ub is None: ub = np.inf
                 bounds.append([lb, ub])

pyfemtet/opt/opt/_scipy_scalar.py

@@ -78,7 +78,7 @@ class ScipyScalarOptimizer(AbstractOptimizer):
         if 'bounds' not in self.minimize_kwargs.keys():
             bounds = []
             for i, row in self.parameters.iterrows():
-                lb, ub = row['lb'], row['ub']
+                lb, ub = row['lower_bound'], row['upper_bound']
                 if lb is None: lb = -np.inf
                 if ub is None: ub = np.inf
                 bounds.append([lb, ub])