pyfemtet 0.9.4__py3-none-any.whl → 1.0.0a0__py3-none-any.whl

pyfemtet/opt/optimizer/_optuna/_botorch_patch/enable_nonlinear_constraint.py

@@ -1,220 +0,0 @@
-from typing import Callable
-from functools import partial
-
-import numpy as np
-
-import torch
-from torch import Tensor
-
-from optuna.study import Study
-from optuna.trial import Trial
-from optuna._transform import _SearchSpaceTransform
-
-from botorch.acquisition import AcquisitionFunction
-from botorch.optim.initializers import gen_batch_initial_conditions
-
-from pyfemtet.opt._femopt_core import Constraint
-from pyfemtet.opt.optimizer import OptunaOptimizer
-from pyfemtet._message import Msg
-
-from pyfemtet.logger import get_module_logger
-
-logger = get_module_logger(__file__, __name__)
-
-
-BotorchConstraint = Callable[[Tensor], Tensor]
-
-
-# 拘束関数に pytorch の自動微分機能を適用するためのクラス
-class GeneralFunctionWithForwardDifference(torch.autograd.Function):
-    """自作関数を pytorch で自動微分するためのクラスです。
-
-    ユーザー定義関数を botorch 形式に変換する過程で微分の計算ができなくなるのでこれが必要です。
-    """
-
-    @staticmethod
-    def forward(ctx, f, xs):
-        ys = f(xs)
-        ctx.save_for_backward(xs, ys)
-        ctx.f = f
-        return ys
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        xs, ys = ctx.saved_tensors
-        f = ctx.f
-        dx = 0.001  # 入力は normalized なので決め打ちでよい
-        diff = []
-        xs = xs.detach()  # xs に余計な計算履歴を残さないために、detachする。
-        for i in range(len(xs)):
-            xs[i] += dx
-            diff.append(torch.sum(grad_output * (f(xs) - ys)))
-            xs[i] -= dx
-        diff = torch.tensor(diff) / dx
-        return None, diff
-
-
-# ユーザー定義関数 (pyfemtet.opt.Constraint) を受け取り、
-# botorch で処理できる callable オブジェクトを作成するクラス
-class ConvertedConstraint:
-    """ユーザーが定義した Constraint を botorch で処理できる形式に変換します。
-
-    `callable()` は形状 `d` の 1 次元テンソルを受け取り、スカラーを返します。
-    """
-
-    def __init__(self, constraint: Constraint, study: Study, bound: str, opt: OptunaOptimizer):
-        self._constraint: Constraint = constraint
-        self._study = study
-        self._bound = bound
-        self._opt = opt
-
-    def __call__(self, x: Tensor) -> Tensor:  # BotorchConstraint
-        """optimize_acqf() に渡される非線形拘束関数の処理です。
-
-        Args:
-            x (Tensor): Normalized parameters. Its length is d (== len(prm)).
-
-        Returns:
-            float Tensor. >= 0 is feasible.
-
-        """
-
-        norm_x = x.detach().numpy()
-        c = evaluate_pyfemtet_cns(self._study, self._constraint, norm_x, self._opt)
-        if self._bound == 'lb':
-            return Tensor([c - self._constraint.lb])
-        elif self._bound == 'ub':
-            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
-    for cns in constraints:
-        c = evaluate_pyfemtet_cns(study, cns, norm_x, opt)
-        if cns.lb is not None:
-            if cns.lb > c:
-                feasible = False
-                break
-        if cns.ub is not None:
-            if cns.ub < c:
-                feasible = False
-                break
-    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.
-
-    Args:
-        study (Study): Optuna study. Use to detect search space from last trial's Distribution objects.
-        cns (Constraint): PyFemtet's format constraint.
-        norm_x (np.ndarray): NORMALIZED values of all parameters.
-        opt (OptunaOptimizer): PyFemtet's optimizer. Used for update values of `opt` and `fem` who may be used in `cns`.
-
-    Returns:
-        bool: feasible or not.
-    """
-    # ===== unnormalize x =====
-    search_space = study.sampler.infer_relative_search_space(study, None)
-    trans = _SearchSpaceTransform(search_space, transform_0_1=True, transform_log=False, transform_step=False)
-    params = trans.untransform(norm_x)
-
-    # ===== update OptunaOptimizer and FEMInterface who is referenced by cns =====
-
-    # opt
-    opt.set_parameter(params)
-
-    # fem
-    if cns.using_fem:
-        df_to_fem = opt.variables.get_variables(format='df', filter_pass_to_fem=True)
-        opt.fem.update_parameter(df_to_fem)
-
-    # ===== calc cns =====
-    return cns.calc(opt.fem)
-
-
-# botorch の optimize_acqf で非線形拘束を使えるようにするクラス。以下を備える。
-#   - 渡すパラメータ nonlinear_constraints を作成する
-#   - gen_initial_conditions で feasible なものを返すラッパー関数
-class NonlinearInequalityConstraints:
-    """botorch の optimize_acqf に parameter constraints を設定するための引数を作成します。"""
-
-    def __init__(self, study: Study, constraints: list[Constraint], opt: OptunaOptimizer):
-        self._study = study
-        self._constraints = constraints
-        self._opt = opt
-
-        self._nonlinear_inequality_constraints = []
-        cns: Constraint
-        for cns in self._constraints:
-            if cns.lb is not None:
-                cns_botorch = ConvertedConstraint(cns, self._study, 'lb', self._opt)
-                item = (lambda x: GeneralFunctionWithForwardDifference.apply(cns_botorch, x), True)
-                self._nonlinear_inequality_constraints.append(item)
-            if cns.ub is not None:
-                cns_botorch = ConvertedConstraint(cns, self._study, 'ub', self._opt)
-                item = (lambda x: GeneralFunctionWithForwardDifference.apply(cns_botorch, x), True)
-                self._nonlinear_inequality_constraints.append(item)
-
-    def _filter_feasible_conditions(self, ic_batch):
-        # List to store feasible initial conditions
-        feasible_ic_list = []
-
-        for each_num_restarts in ic_batch:
-            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
-
-            if feasible_q_list:  # Only add if there are feasible rows
-                feasible_ic_list.append(torch.stack(feasible_q_list))
-
-        # Stack feasible conditions back into tensor format
-        if feasible_ic_list:
-            return torch.stack(feasible_ic_list)
-        else:
-            return None  # Return None if none are feasible
-
-    @staticmethod
-    def _generate_random_initial_conditions(shape):
-        # Generates random initial conditions with the same shape as ic_batch
-        return torch.rand(shape)
-
-    def _generate_feasible_initial_conditions(self, *args, **kwargs):
-        # A `num_restarts x q x d` tensor of initial conditions.
-        ic_batch = gen_batch_initial_conditions(*args, **kwargs)
-        feasible_ic_batch = self._filter_feasible_conditions(ic_batch)
-
-        while feasible_ic_batch is None:
-            # Generate new random ic_batch with the same shape
-            print('警告: gen_batch_initial_conditions() は feasible な初期値を提案しませんでした。'
-                  'パラメータ提案を探索するための初期値をランダムに選定します。')
-            random_ic_batch = self._generate_random_initial_conditions(ic_batch.shape)
-            feasible_ic_batch = self._filter_feasible_conditions(random_ic_batch)
-
-        return feasible_ic_batch
-
-    def create_kwargs(self) -> dict:
-        """
-        nonlinear_inequality_constraints:
-            非線形不等式制約を表すタプルのリスト。
-            タプルの最初の要素は、`callable(x) >= 0` という形式の制約を表す呼び出し可能オブジェクトです。
-            2 番目の要素はブール値で、点内制約の場合は `True`
-            制約は後で scipy ソルバーに渡されます。
-            この場合、`batch_initial_conditions` を渡す必要があります。
-            非線形不等式制約を使用するには、`batch_limit` を 1 に設定する必要もあります。
-                これは、`options` で指定されていない場合は自動的に行われます。
-        """
-        return dict(
-            q=1,
-            options=dict(
-                batch_limit=1,
-            ),
-            nonlinear_inequality_constraints=self._nonlinear_inequality_constraints,
-            ic_generator=self._generate_feasible_initial_conditions,
-        )

pyfemtet/opt/optimizer/_optuna/_optuna.py

@@ -1,434 +0,0 @@
-# typing
-from typing import Iterable
-
-# built-in
-import os
-import inspect
-import gc
-
-# 3rd-party
-import optuna
-from optuna.trial import TrialState, FrozenTrial
-from optuna.study import MaxTrialsCallback, Study
-
-# pyfemtet relative
-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
-
-# filter warnings
-import warnings
-from optuna.exceptions import ExperimentalWarning
-
-
-optuna.logging.set_verbosity(optuna.logging.ERROR)
-
-warnings.filterwarnings('ignore', category=ExperimentalWarning)
-
-
-class OptunaMethodChecker(OptimizationMethodChecker):
-    def check_multi_objective(self, raise_error=True): return True
-    def check_timeout(self, raise_error=True): return True
-    def check_parallel(self, raise_error=True): return True
-    def check_constraint(self, raise_error=True): return True
-    def check_strict_constraint(self, raise_error=True): return True
-    def check_skip(self, raise_error=True): return True
-    def check_seed(self, raise_error=True): return True
-
-
-class OptunaOptimizer(AbstractOptimizer):
-    """Optimizer using ```optuna```.
-
-    This class provides an interface for the optimization
-    engine using Optuna. For more details, please refer to
-    the Optuna documentation.
-
-    See Also:
-        https://optuna.readthedocs.io/en/stable/reference/index.html
-
-    Args:
-        sampler_class (optuna.samplers.BaseSampler, optional):
-            A sampler class from Optuna. If not specified,
-            ```optuna.samplers.TPESampler``` is specified.
-            This defines the sampling strategy used during
-            optimization. Defaults to None.
-        sampler_kwargs (dict, optional):
-            A dictionary of keyword arguments to be passed to
-            the sampler class. This allows for customization
-            of the sampling process. Defaults to None.
-        add_init_method (str or Iterable[str], optional):
-            A method or a collection of methods to be added
-            during initialization. This can be used to specify
-            additional setup procedures.
-            Currently, the only valid value is 'LHS'
-            (using Latin Hypercube Sampling).
-            Defaults to None.
-
-    Warnings:
-        Do not include ```constraints_func``` in ```sampler_kwargs```.
-        It is generated and provided by :func:`FEMOpt.add_constraint`.
-
-    """
-
-    def __init__(
-            self,
-            sampler_class: optuna.samplers.BaseSampler or None = None,
-            sampler_kwargs: dict or None = None,
-            add_init_method: str or Iterable[str] or None = None
-    ):
-        super().__init__()
-        self.study_name = None
-        self.storage = None
-        self.study = None
-        self.optimize_callbacks = []
-        self.sampler_class = optuna.samplers.TPESampler if sampler_class is None else sampler_class
-        self.sampler_kwargs = dict() if sampler_kwargs is None else sampler_kwargs
-        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._temporary_storage = None
-        self._temporary_storage_path = '_pyfemtet_temporary_file.db'
-
-    def _objective(self, trial):
-
-        logger.info('')
-        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:
-            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,
-                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 経由で変数を取得して 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]
-        for cns in strict_constraints:
-            feasible = True
-            cns_value = cns.calc(self.fem)
-            if cns.lb is not None:
-                feasible = feasible and (cns_value >= cns.lb)
-            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
-                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.
-
-        # 計算
-        try:
-            _, _y, c = self.f(x)  # f の中で info は出している
-        except (ModelError, MeshError, SolveError) as e:
-            # 中断の確認 (解析中に interrupt されている場合対策)
-            if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
-                self.worker_status.set(OptimizationStatus.INTERRUPTING)
-                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
-            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 の更新
-        if len(self.constraints) > 0:
-            _c = []  # <= 0 is feasible
-            for (name, cns), c_value in zip(self.constraints.items(), c):
-                lb, ub = cns.lb, cns.ub
-                if lb is not None:  # fun >= lb  <=>  lb - fun <= 0
-                    _c.append(lb - c_value)
-                if ub is not None:  # ub >= fun  <=>  fun - ub <= 0
-                    _c.append(c_value - ub)
-            trial.set_user_attr('constraints', _c)
-
-        # 中断の確認 (解析中に interrupt されている場合対策)
-        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):
-        # if break trial without weak constraint calculation, return 1 (as infeasible).
-        if 'constraints' in trial.user_attrs.keys():
-            return trial.user_attrs['constraints']
-        else:
-            _c = []
-            for name, cns in self.constraints.items():
-                lb, ub = cns.lb, cns.ub
-                if lb is not None:
-                    _c.append(1.)
-                if ub is not None:
-                    _c.append(1.)
-            return _c
-
-    def _setup_before_parallel(self):
-        """Create storage, study and set initial parameter."""
-
-        # create storage
-        self.study_name = 'pyfemtet-study'
-        storage_path = os.path.splitext(self.history.path)[0] + '.db'  # history と同じところに保存
-        if self.is_cluster:  # remote cluster なら scheduler の working dir に保存
-            storage_path = os.path.splitext(os.path.basename(self.history.path))[0] + '.db'
-
-        # callback to terminate
-        if self.n_trials is not None:
-            n_trials = self.n_trials
-
-            # restart である場合、追加 N 回と見做す
-            if self.history.is_restart:
-                n_existing_trials = len(self.history.get_df())
-                n_trials += n_existing_trials
-
-            self.optimize_callbacks.append(MaxTrialsCallback(n_trials, states=(TrialState.COMPLETE,)))
-
-        # if not restart, create study if storage is not exists
-        if not self.history.is_restart:
-
-            self.storage = optuna.integration.dask.DaskStorage(
-                f'sqlite:///{storage_path}',
-            )
-
-            self.study = optuna.create_study(
-                study_name=self.study_name,
-                storage=self.storage,
-                load_if_exists=True,
-                directions=['minimize'] * len(self.objectives),
-            )
-
-            # 初期値の設定
-            if len(self.study.trials) == 0:  # リスタートでなければ
-                # ユーザーの指定した初期値
-                params = self.variables.get_variables('dict', filter_parameter=True)
-                self.study.enqueue_trial(params, user_attrs={"message": "initial"})
-
-                # add_initial_parameter で追加された初期値
-                for prm, prm_set_name in self.additional_initial_parameter:
-                    if type(prm) is dict:
-                        assert prm.keys() == params.keys(), Msg.ERR_INCONSISTENT_PARAMETER
-                    else:
-                        assert len(prm) == len(params.keys()), Msg.ERR_INCONSISTENT_PARAMETER
-                        prm = dict(zip(params.keys(), prm))
-
-                    self.study.enqueue_trial(
-                        prm,
-                        user_attrs={"message": prm_set_name}
-                    )
-
-                # add_init で指定された方法による初期値
-                if 'LHS' in self.additional_initial_methods:
-                    names = []
-                    bounds = []
-                    for i, row in self.get_parameter('df').iterrows():
-                        names.append(row['name'])
-                        lb = row['lower_bound']
-                        ub = row['upper_bound']
-                        bounds.append([lb, ub])
-                    data = generate_lhs(bounds, seed=self.seed)
-                    for datum in data:
-                        d = {}
-                        for name, v in zip(names, datum):
-                            d[name] = v
-                        self.study.enqueue_trial(
-                            d, user_attrs={"message": "additional initial (Latin Hypercube Sampling)"}
-                        )
-
-        # if is_restart, load study
-        else:
-            if not os.path.exists(storage_path):
-                raise FileNotFoundError(storage_path)
-            self.storage = optuna.integration.dask.DaskStorage(
-                f'sqlite:///{storage_path}',
-            )
-
-            # if TPESampler, create temporary study
-            # due to instability in case of many pruned trials.
-            from optuna.samplers import TPESampler
-            if issubclass(self.sampler_class, TPESampler):
-
-                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}',
-                )
-
-                study = optuna.load_study(
-                    study_name=None,
-                    storage=self.storage,
-                    sampler=None,
-                )
-
-                _study = optuna.create_study(
-                    study_name='tmp',
-                    storage=self._temporary_storage,
-                    load_if_exists=True,
-                    directions=['minimize'] * len(self.objectives),
-                )
-
-                # Copy COMPLETE trials to temporary study.
-                existing_trials = study.get_trials(states=(optuna.trial.TrialState.COMPLETE,))
-                _study.add_trials(existing_trials)
-
-    def add_init_parameter(
-            self,
-            parameter: dict or Iterable,
-            name: str or None = None,
-    ):
-        """Add additional initial parameter for evaluate.
-
-        The parameter set is ignored if the main() is continued.
-
-        Args:
-            parameter (dict or Iterable): Parameter to evaluate before run optimization algorithm.
-            name (str or None): Optional. If specified, the name is saved in the history row. Default to None.
-
-        """
-        if name is None:
-            name = 'additional initial'
-        else:
-            name = f'additional initial ({name})'
-        self.additional_initial_parameter.append([parameter, name])
-
-    def run(self):
-        """Set random seed, sampler, study and run study.optimize()."""
-
-        # (re)set random seed
-        seed = self.seed
-        if seed is not None:
-            if self.subprocess_idx is not None:
-                seed += self.subprocess_idx
-
-        # restore sampler
-        if len(self.constraints) > 0:
-            self.sampler_kwargs.update(
-                constraints_func=self._constraint
-            )
-        if seed is not None:
-            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(
-            **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
-        self.storage: optuna.storages.BaseStorage
-        studies = self.storage.get_all_studies()
-        if self.study_name in [s.study_name for s in studies]:
-            pass
-
-        elif len(studies) >= 1:
-            self.study_name = studies[-1].study_name
-
-        else:
-            raise ValueError('An empty db is passed.')
-
-        study = optuna.load_study(
-            study_name=self.study_name,
-            storage=self.storage,
-            sampler=sampler,
-        )
-
-        # use temporary storage or not
-        if self._temporary_storage is None:
-            # run
-            study.optimize(
-                self._objective,
-                timeout=self.timeout,
-                callbacks=self.optimize_callbacks,
-            )
-
-        else:
-            # load study
-            _study = optuna.load_study(
-                study_name="tmp",
-                storage=self._temporary_storage,
-                sampler=sampler,
-            )
-
-            # Add callback to coppy back each trial.
-            class CopyBack:
-                def __call__(self, _: Study, trial: FrozenTrial) -> None:
-                    # Write back added trials to the existing study.
-                    study.add_trial(trial)
-            self.optimize_callbacks.append(CopyBack())
-
-            # run
-            _study.optimize(
-                self._objective,
-                timeout=self.timeout,
-                callbacks=self.optimize_callbacks,
-            )
-
-            # clean up
-            try:
-                self._temporary_storage.remove_session()
-                del self._temporary_storage
-                del _study
-                gc.collect()
-                if os.path.exists(self._temporary_storage_path):
-                    os.remove(self._temporary_storage_path)
-            except:
-                pass