pyfemtet 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

pyfemtet/opt/optimizer/{_optuna_botorchsampler_parameter_constraint_helper.py → _optuna/_botorch_patch/enable_nonlinear_constraint.py}

@@ -17,46 +17,12 @@ from pyfemtet.opt._femopt_core import Constraint
 from pyfemtet.opt.optimizer import OptunaOptimizer, logger
 from pyfemtet._message import Msg
 
-from time import time
-
-
-__all__ = ['do_patch']
 
 
 BotorchConstraint = Callable[[Tensor], Tensor]
 
 
-def do_patch(
-    study: Study,
-    constraints: dict[str, Constraint],
-    opt: OptunaOptimizer,
-):
-    """BoTorchSampler の optimize_acqf をパッチし、パラメータ拘束が実施できるようにします。
-
-    Args:
-        study (Study): Optuna study. Use to calculate bounds.
-        constraints (dict[str, Constraint]): Constraints.
-        opt (OptunaOptimizer): OptunaOptimizer.
-    """
-    import optuna_integration
-
-    from optuna_integration import version
-    if int(version.__version__.split('.')[0]) >= 4:
-        target_fun = optuna_integration.botorch.botorch.optimize_acqf
-    else:
-        target_fun = optuna_integration.botorch.optimize_acqf
-
-    new_fun: callable = OptimizeReplacedACQF(target_fun)
-    new_fun.set_constraints(list(constraints.values()))
-    new_fun.set_study(study)
-    new_fun.set_opt(opt)
-
-    if int(version.__version__.split('.')[0]) >= 4:
-        optuna_integration.botorch.botorch.optimize_acqf = new_fun
-    else:
-        optuna_integration.botorch.optimize_acqf = new_fun
-
-
+# 拘束関数に pytorch の自動微分機能を適用するためのクラス
 class GeneralFunctionWithForwardDifference(torch.autograd.Function):
     """自作関数を pytorch で自動微分するためのクラスです。
 
@@ -85,6 +51,8 @@ class GeneralFunctionWithForwardDifference(torch.autograd.Function):
         return None, diff
 
 
+# ユーザー定義関数 (pyfemtet.opt.Constraint) を受け取り、
+# botorch で処理できる callable オブジェクトを作成するクラス
 class ConvertedConstraint:
     """ユーザーが定義した Constraint を botorch で処理できる形式に変換します。
 
@@ -116,6 +84,7 @@ class ConvertedConstraint:
             return Tensor([self._constraint.ub - c])
 
 
+# list[pyfemtet.opt.Constraint] について、正規化された入力に対し、 feasible or not を返す関数
 def is_feasible(study: Study, constraints: list[Constraint], norm_x: np.ndarray, opt: OptunaOptimizer) -> bool:
     feasible = True
     cns: Constraint
@@ -132,6 +101,7 @@ def is_feasible(study: Study, constraints: list[Constraint], norm_x: np.ndarray,
     return feasible
 
 
+# 正規化された入力を受けて pyfemtet.opt.Constraint を評価する関数
 def evaluate_pyfemtet_cns(study: Study, cns: Constraint, norm_x: np.ndarray, opt: OptunaOptimizer) -> float:
     """Evaluate given constraint function by given NORMALIZED x.
 
@@ -163,6 +133,9 @@ def evaluate_pyfemtet_cns(study: Study, cns: Constraint, norm_x: np.ndarray, opt
     return cns.calc(opt.fem)
 
 
+# botorch の optimize_acqf で非線形拘束を使えるようにするクラス。以下を備える。
+#   - 渡すパラメータ nonlinear_constraints を作成する
+#   - gen_initial_conditions で feasible なものを返すラッパー関数
 class NonlinearInequalityConstraints:
     """botorch の optimize_acqf に parameter constraints を設定するための引数を作成します。"""
 
@@ -191,7 +164,7 @@ class NonlinearInequalityConstraints:
             feasible_q_list = []
             for each_q in each_num_restarts:
                 norm_x: np.ndarray = each_q.numpy()  # normalized parameters
-                
+
                 if is_feasible(self._study, self._constraints, norm_x, self._opt):
                     feasible_q_list.append(each_q)  # Keep only feasible rows
 
@@ -242,93 +215,3 @@ class NonlinearInequalityConstraints:
             nonlinear_inequality_constraints=self._nonlinear_inequality_constraints,
             ic_generator=self._generate_feasible_initial_conditions,
         )
-
-
-class AcquisitionFunctionWithPenalty(AcquisitionFunction):
-    """獲得関数に infeasible 項を追加します。"""
-
-    # noinspection PyAttributeOutsideInit
-    def set_acqf(self, acqf):
-        self._acqf = acqf
-
-    # noinspection PyAttributeOutsideInit
-    def set_constraints(self, constraints: list[Constraint]):
-        self._constraints: list[Constraint] = constraints
-
-    # noinspection PyAttributeOutsideInit
-    def set_study(self, study: Study):
-        self._study: Study = study
-
-    # noinspection PyAttributeOutsideInit
-    def set_opt(self, opt: OptunaOptimizer):
-        self._opt = opt
-
-    def forward(self, X: "Tensor") -> "Tensor":
-        """
-
-        Args:
-            X (Tensor): batch_size x 1 x n_params tensor.
-
-        Returns:
-            Tensor: batch_size tensor.
-
-        """
-        base = self._acqf.forward(X)
-
-        norm_x: np.ndarray
-        for i, _norm_x in enumerate(X.detach().numpy()):
-            
-            cns: Constraint
-            for cns in self._constraints:
-                feasible = is_feasible(self._study, [cns], _norm_x[0], self._opt)
-                if not feasible:
-                    base[i] = base[i] * 0.  # ペナルティ
-                    break
-
-        return base
-
-
-class OptimizeReplacedACQF(partial):
-    """optimize_acqf をこの partial 関数に置き換えます。"""
-
-    # noinspection PyAttributeOutsideInit
-    def set_constraints(self, constraints: list[Constraint]):
-        self._constraints: list[Constraint] = constraints
-
-    # noinspection PyAttributeOutsideInit
-    def set_study(self, study: Study):
-        self._study: Study = study
-
-    # noinspection PyAttributeOutsideInit
-    def set_opt(self, opt: OptunaOptimizer):
-        self._opt = opt
-
-    def __call__(self, *args, **kwargs):
-        """置き換え先の関数の処理内容です。
-
-        kwargs を横入りして追記することで拘束を実現します。
-        """
-
-        logger.info(Msg.START_CANDIDATE_WITH_PARAMETER_CONSTRAINT)
-
-        # FEM の更新が必要な場合、時間がかかることが多いので警告を出す
-        if any([cns.using_fem for cns in self._constraints]):
-            logger.warning(Msg.WARN_UPDATE_FEM_PARAMETER_TOOK_A_LONG_TIME)
-
-        # 獲得関数に infeasible な場合のペナルティ項を追加します。
-        acqf = kwargs['acq_function']
-        new_acqf = AcquisitionFunctionWithPenalty(...)
-        new_acqf.set_acqf(acqf)
-        new_acqf.set_constraints(self._constraints)
-        new_acqf.set_study(self._study)
-        new_acqf.set_opt(self._opt)
-        kwargs['acq_function'] = new_acqf
-
-        # optimize_acqf の探索に parameter constraints を追加します。
-        nlic = NonlinearInequalityConstraints(self._study, self._constraints, self._opt)
-        kwargs.update(nlic.create_kwargs())
-
-        # replace other arguments
-        ...
-
-        return super().__call__(*args, **kwargs)

pyfemtet/opt/optimizer/{_optuna.py → _optuna/_optuna.py}

@@ -3,15 +3,15 @@ from typing import Iterable
 
 # built-in
 import os
+import inspect
 
 # 3rd-party
-import numpy as np
 import optuna
 from optuna.trial import TrialState
 from optuna.study import MaxTrialsCallback
 
 # pyfemtet relative
-from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs, Constraint
+from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
 from pyfemtet.opt.optimizer import AbstractOptimizer, logger, OptimizationMethodChecker
 from pyfemtet.core import MeshError, ModelError, SolveError
 from pyfemtet._message import Msg
@@ -86,17 +86,24 @@ 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._do_monkey_patch = False
 
     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 =====')
+
         # 中断の確認 (FAIL loop に陥る対策)
         if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
             self.worker_status.set(OptimizationStatus.INTERRUPTING)
             trial.study.stop()  # 現在実行中の trial を最後にする
+            self._retry_counter = 0
             return None  # set TrialState FAIL
 
         # candidate x and update parameters
+        logger.info('Searching new parameter set...')
         for prm in self.variables.get_variables(format='raw', filter_parameter=True):
             value = trial.suggest_float(
                 name=prm.name,
@@ -126,9 +133,11 @@ class OptunaOptimizer(AbstractOptimizer):
             if cns.ub is not None:
                 feasible = feasible and (cns.ub >= cns_value)
             if not feasible:
+                logger.info('----- Out of constraint! -----')
                 logger.info(Msg.INFO_INFEASIBLE)
                 logger.info(f'Constraint: {cns.name}')
                 logger.info(self.variables.get_variables('dict', filter_parameter=True))
+                self._retry_counter += 1
                 raise optuna.TrialPruned()  # set TrialState PRUNED because FAIL causes similar candidate loop.
 
         # 計算
@@ -142,6 +151,15 @@ class OptunaOptimizer(AbstractOptimizer):
                 trial.study.stop()  # 現在実行中の trial を最後にする
                 return None  # set TrialState FAIL
 
+            logger.warning('----- Infeasible! -----')
+            logger.warning(Msg.INFO_INFEASIBLE)
+            logger.warning(f'Hidden Constraint ({type(e).__name__})')
+            logger.warning(self.variables.get_variables('dict', filter_parameter=True))
+            logger.warning('Please consider to determine the cause'
+                           'of the above error and modify the model'
+                           'or analysis.')
+
+            self._retry_counter += 1
             raise optuna.TrialPruned()  # set TrialState PRUNED because FAIL causes similar candidate loop.
 
         # 拘束 attr の更新
@@ -159,9 +177,11 @@ class OptunaOptimizer(AbstractOptimizer):
         if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
             self.worker_status.set(OptimizationStatus.INTERRUPTING)
             trial.study.stop()  # 現在実行中の trial を最後にする
+            self._retry_counter = 0
             return None  # set TrialState FAIL
 
         # 結果
+        self._retry_counter = 0
         return tuple(_y)
 
     def _constraint(self, trial):
@@ -295,10 +315,20 @@ class OptunaOptimizer(AbstractOptimizer):
             self.sampler_kwargs.update(
                 seed=seed
             )
+        parameters = inspect.signature(self.sampler_class.__init__).parameters
+        sampler_kwargs = dict()
+        for k, v in self.sampler_kwargs.items():
+            if k in parameters.keys():
+                sampler_kwargs.update({k: v})
         sampler = self.sampler_class(
-            **self.sampler_kwargs
+            **sampler_kwargs
         )
 
+        from pyfemtet.opt.optimizer._optuna._pof_botorch import PoFBoTorchSampler
+        if isinstance(sampler, PoFBoTorchSampler):
+            sampler._pyfemtet_constraints = [cns for cns in self.constraints.values() if cns.strict]
+            sampler._pyfemtet_optimizer = self
+
         # load study
         study = optuna.load_study(
             study_name=self.study_name,
@@ -306,21 +336,62 @@ class OptunaOptimizer(AbstractOptimizer):
             sampler=sampler,
         )
 
-        # monkey patch
-        if self._do_monkey_patch:
-            assert isinstance(sampler, optuna.integration.BoTorchSampler), Msg.ERR_PARAMETER_CONSTRAINT_ONLY_BOTORCH
+        # 一時的な実装。
+        #   TPESampler の場合、リスタート時などの場合で、
+        #   Pruned が多いとエラーを起こす挙動があるので、
+        #   Pruned な Trial は remove したい。
+        #   study.remove_trial がないので、一度ダミー
+        #   study を作成して最適化終了後に結果をコピーする。
+        if isinstance(sampler, optuna.samplers.TPESampler):
+            tmp_db = f"tmp{self.subprocess_idx}.db"
+            if os.path.exists(tmp_db):
+                os.remove(tmp_db)
+
+            _study = optuna.create_study(
+                study_name="tmp",
+                storage=f"sqlite:///{tmp_db}",
+                sampler=sampler,
+                directions=['minimize']*len(self.objectives),
+                load_if_exists=False,
+            )
 
-            from pyfemtet.opt.optimizer._optuna_botorchsampler_parameter_constraint_helper import do_patch
+            # 既存の trials のうち COMPLETE のものを取得
+            existing_trials = study.get_trials(states=(optuna.trial.TrialState.COMPLETE,))
+            _study.add_trials(existing_trials)
 
-            do_patch(
-                study,
-                self.constraints,
-                self
+            # run
+            _study.optimize(
+                self._objective,
+                timeout=self.timeout,
+                callbacks=self.optimize_callbacks,
             )
 
-        # run
-        study.optimize(
-            self._objective,
-            timeout=self.timeout,
-            callbacks=self.optimize_callbacks,
-        )
+            # trial.number と trial_id は _study への add_trials 時に
+            # 振りなおされるため重複したものをフィルタアウトするために
+            # datetime_start を利用。
+            added_trials = []
+            for _trial in _study.get_trials():
+                if _trial.datetime_start not in [t.datetime_start for t in existing_trials]:
+                    added_trials.append(_trial)
+
+            # Write back added trials to the existing study.
+            study.add_trials(added_trials)
+
+            # clean up
+            from optuna.storages import get_storage
+            storage = get_storage(f"sqlite:///{tmp_db}")
+            storage.remove_session()
+            del _study
+            del storage
+            import gc
+            gc.collect()
+            if os.path.exists(tmp_db):
+                os.remove(tmp_db)
+
+        else:
+            # run
+            study.optimize(
+                self._objective,
+                timeout=self.timeout,
+                callbacks=self.optimize_callbacks,
+            )