pyfemtet 0.9.5__py3-none-any.whl → 1.0.0b0__py3-none-any.whl

pyfemtet/opt/optimizer/_base.py

@@ -1,376 +0,0 @@
-# typing
-from abc import ABC, abstractmethod
-from typing import Optional
-
-# built-in
-import traceback
-from time import sleep
-
-# 3rd-party
-import numpy as np
-
-# pyfemtet relative
-from pyfemtet.opt.interface import FEMInterface
-from pyfemtet.opt._femopt_core import OptimizationStatus, Objective, Constraint
-from pyfemtet._message import Msg
-from pyfemtet.opt.optimizer.parameter import ExpressionEvaluator, Parameter
-
-# logger
-from pyfemtet.logger import get_module_logger
-
-logger = get_module_logger('opt.optimizer', __name__)
-
-
-class OptimizationMethodChecker:
-    """Check implementation of PyFemtet functions."""
-
-    def __init__(self, opt):
-        self.opt = opt
-
-    def check_parallel(self, raise_error=True):
-        function = 'parallel-processing'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_timeout(self, raise_error=True):
-        function = 'timeout'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_multi_objective(self, raise_error=True):
-        function = 'multi-objective'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_strict_constraint(self, raise_error=True):
-        function = 'strict-constraint'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_constraint(self, raise_error=True):
-        function = 'constraint'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_skip(self, raise_error=True):
-        function = 'skip'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_seed(self, raise_error=True):
-        function = 'random seed setting'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-    def check_incomplete_bounds(self, raise_error=True):
-        function = 'optimize with no or incomplete bounds'
-        method = str(type(self.opt))
-        message = (Msg.ERR_NOT_IMPLEMENTED
-                   + f'method:{method}, function:{function}')
-        if raise_error:
-            raise NotImplementedError(message)
-        else:
-            logger.warning(message)
-
-
-class AbstractOptimizer(ABC):
-    """Abstract base class for an interface of optimization library.
-
-    Attributes:
-        fem (FEMInterface): The finite element method object.
-        fem_class (type): The class of the finite element method object.
-        fem_kwargs (dict): The keyword arguments used to instantiate the finite element method object.
-        variables (ExpressionEvaluator): The variables using optimization process including parameters.
-        objectives (dict[str, Objective]): A dictionary containing the objective functions used in the optimization.
-        constraints (dict[str, Constraint]): A dictionary containing the constraint functions used in the optimization.
-        history (History): An actor object that records the history of each iteration in the optimization process.
-        seed (int or None): The random seed used for random number generation during the optimization process.
-
-    """
-
-    def __init__(self):
-        self.fem = None
-        self.fem_class = None
-        self.fem_kwargs = dict()
-        self.variables: ExpressionEvaluator = ExpressionEvaluator()
-        self.objectives: dict[str, Objective] = dict()
-        self.constraints: dict[str, Constraint] = dict()
-        self.entire_status = None  # actor
-        self.history = None  # actor
-        self.worker_status = None  # actor
-        self.message = ''
-        self.seed = None
-        self.timeout = None
-        self.n_trials = None
-        self.is_cluster = False
-        self.subprocess_idx = None
-        self._exception = None
-        self.method_checker: OptimizationMethodChecker = OptimizationMethodChecker(self)
-        self._retry_counter = 0
-
-    # ===== algorithm specific methods =====
-    @abstractmethod
-    def run(self) -> None:
-        """Start optimization."""
-        pass
-
-    # ----- FEMOpt interfaces -----
-    @abstractmethod
-    def _setup_before_parallel(self, *args, **kwargs):
-        """Setup before parallel processes are launched."""
-        pass
-
-    # ===== calc =====
-    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]:
-                The list of internal objective values,
-                un-normalized objective values and
-                constraint values.
-
-        """
-
-
-        if isinstance(x, np.float64):
-            x = np.array([x])
-
-        # Optimizer の x の更新
-        self.set_parameter_values(x)
-        logger.info(f'input: {x}')
-
-        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.
-
-            # 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)]
-
-            c = [cns.calc(self.fem) for cns in self.constraints.values()]
-
-        else:
-            y, c = self.history.generate_hidden_infeasible_result()
-            _y = y
-
-        # register to history
-        df_to_opt = self.variables.get_variables(
-            format='df',
-            filter_parameter=True,
-        )
-        self.history.record(
-            df_to_opt,
-            self.objectives,
-            self.constraints,
-            y,
-            c,
-            self.message,
-            postprocess_func=self.fem._postprocess_func if not _record_infeasible else None,
-            postprocess_args=self.fem._create_postprocess_args() if not _record_infeasible else None,
-        )
-
-        logger.info(f'output: {y}')
-
-        return np.array(y), np.array(_y), np.array(c)
-
-    # ===== parameter processing =====
-    def get_parameter(self, format='dict'):
-        """Returns the parameters in the specified format.
-
-        Args:
-            format (str, optional):
-                The desired format of the parameters.
-                Can be 'df' (DataFrame),
-                'values' (np.ndarray),
-                'dict' or
-                'raw' (list of Variable object).
-                Defaults to 'dict'.
-
-        Returns:
-            The parameters in the specified format.
-
-        Raises:
-            ValueError: If an invalid format is provided.
-
-        """
-        return self.variables.get_variables(format=format, filter_parameter=True)
-
-    def set_parameter(self, params: dict[str, float]) -> None:
-        """Update parameter.
-
-        Args:
-            params (dict):
-                Key is the name of parameter and
-                the value is the value of it.
-                The partial set is available.
-
-        """
-        for name, value in params.items():
-            self.variables.variables[name].value = value
-        self.variables.evaluate()
-
-    def set_parameter_values(self, values: np.ndarray) -> None:
-        """Update parameter with values.
-
-        Args:
-            values (np.ndarray): Values of all parameters.
-
-        """
-        prm_names = self.variables.get_parameter_names()
-        assert len(values) == len(prm_names)
-        self.set_parameter({k: v for k, v in zip(prm_names, values)})
-
-    # ===== FEMOpt interfaces =====
-    def _reconstruct_fem(self, skip_reconstruct=False):
-        """Reconstruct FEMInterface in a subprocess."""
-        # reconstruct fem
-        if not skip_reconstruct:
-            self.fem = self.fem_class(**self.fem_kwargs)
-
-        # COM 定数の restore
-        for obj in self.objectives.values():
-            obj._restore_constants()
-        for cns in self.constraints.values():
-            cns._restore_constants()
-
-    def _check_interruption(self):
-        """"""
-        if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
-            self.worker_status.set(OptimizationStatus.INTERRUPTING)
-            self._finalize()
-            return True
-        else:
-            return False
-
-    def _finalize(self):
-        """Destruct fem and set worker status."""
-        self.fem.quit()
-        if not self.worker_status.get() == OptimizationStatus.CRASHED:
-            self.worker_status.set(OptimizationStatus.TERMINATED)
-
-    # run via FEMOpt (considering parallel processing)
-    def _run(
-            self,
-            subprocess_idx,  # 自身が何番目の並列プロセスであるかを示す連番
-            worker_status_list,  # 他の worker の status オブジェクト
-            wait_setup,  # 他の worker の status が ready になるまで待つか
-            skip_reconstruct=False,  # reconstruct fem を行うかどうか
-            space_dir=None,  # 特定の space_dir を使うかどうか
-    ) -> Optional[Exception]:
-
-        # 自分の worker_status の取得
-        self.subprocess_idx = subprocess_idx
-        self.worker_status = worker_status_list[subprocess_idx]
-        self.worker_status.set(OptimizationStatus.LAUNCHING_FEM)
-
-        if self._check_interruption():
-            return None
-
-        # set_fem をはじめ、終了したらそれを示す
-        self._reconstruct_fem(skip_reconstruct)
-        self.fem._setup_after_parallel(opt=self, space_dir=space_dir)
-        self.worker_status.set(OptimizationStatus.WAIT_OTHER_WORKERS)
-
-        # wait_setup or not
-        if wait_setup:
-            while True:
-                if self._check_interruption():
-                    return None
-                # 他のすべての worker_status が wait 以上になったら break
-                if all([ws.get() >= OptimizationStatus.WAIT_OTHER_WORKERS for ws in worker_status_list]):
-                    # リソースの競合等を避けるため
-                    # break する前に index 秒待つ
-                    sleep(int(subprocess_idx))
-                    break
-                sleep(1)
-        else:
-            if self._check_interruption():
-                return None
-
-        # set status running
-        if self.entire_status.get() < OptimizationStatus.RUNNING:
-            self.entire_status.set(OptimizationStatus.RUNNING)
-        self.worker_status.set(OptimizationStatus.RUNNING)
-
-        # run and finalize
-        try:
-            self.run()
-        except Exception as e:
-            logger.error("=================================")
-            logger.error("An unexpected error has occurred!")
-            logger.error("=================================")
-            logger.error(f'{type(e).__name__}: {e}')
-            traceback.print_exc()
-            self._exception = e
-            self.worker_status.set(OptimizationStatus.CRASHED)
-        finally:
-            self._finalize()
-
-        return self._exception
-
-
-if __name__ == '__main__':
-    class Optimizer(AbstractOptimizer):
-        def run(self): pass
-        def _setup_before_parallel(self, *args, **kwargs): pass
-
-    opt = Optimizer()
-    opt.set_parameter(
-        dict(
-            prm1=0.,
-            prm2=1.,
-        )
-    )

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,
-        )