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

pyfemtet/opt/interface/_femtet_with_sldworks.py

@@ -10,10 +10,30 @@ from pythoncom import CoInitialize, CoUninitialize
 
 from pyfemtet.core import ModelError
 from pyfemtet.opt.interface import FemtetInterface, logger
-from pyfemtet.message import Msg
+from pyfemtet._message import Msg
 
 
 class FemtetWithSolidworksInterface(FemtetInterface):
+    """Control Femtet and Solidworks.
+
+    Using this class, you can import CAD files created
+    in Solidworks through the Parasolid format into a
+    Femtet project. It allows you to pass design
+    variables to Solidworks, update the model, and
+    perform analysis using the updated model in Femtet.
+
+
+    Args:
+        sldprt_path (str):
+            The path to .sldprt file containing the
+            CAD data from which the import is made.
+        **kwargs:
+            For other arguments, please refer to the
+            :class:`FemtetInterface` class.
+
+    """
+
+
     # 定数の宣言
     swThisConfiguration = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swInConfigurationOpts_e.html
     swAllConfiguration = 2
@@ -76,7 +96,7 @@ class FemtetWithSolidworksInterface(FemtetInterface):
         CoInitialize()
         self.initialize_sldworks_connection()
 
-    def update_model(self, parameters: pd.DataFrame):
+    def update_model(self, parameters: pd.DataFrame, with_warning=False):
         """Update .x_t"""
 
         self.parameters = parameters.copy()

pyfemtet/opt/optimizer/__init__.py

@@ -1,12 +1,16 @@
 from pyfemtet.opt.optimizer._base import AbstractOptimizer, logger, OptimizationMethodChecker
-from pyfemtet.opt.optimizer._optuna import OptunaOptimizer
+from pyfemtet.opt.optimizer._optuna._optuna import OptunaOptimizer
 from pyfemtet.opt.optimizer._scipy import ScipyOptimizer
 from pyfemtet.opt.optimizer._scipy_scalar import ScipyScalarOptimizer
 
+from pyfemtet.opt.optimizer._optuna._pof_botorch import PoFBoTorchSampler, PoFConfig
+
 __all__ = [
     'ScipyScalarOptimizer',
     'ScipyOptimizer',
     'OptunaOptimizer',
     'AbstractOptimizer',
     'logger',
+    'PoFBoTorchSampler',
+    'PoFConfig',
 ]

pyfemtet/opt/optimizer/_base.py

@@ -8,13 +8,12 @@ from time import sleep
 
 # 3rd-party
 import numpy as np
-import pandas as pd
 
 # pyfemtet relative
-from pyfemtet.opt.interface import FemtetInterface
+from pyfemtet.opt.interface import FEMInterface
 from pyfemtet.opt._femopt_core import OptimizationStatus, Objective, Constraint
-from pyfemtet.message import Msg
-from pyfemtet.opt.parameter import ExpressionEvaluator
+from pyfemtet._message import Msg
+from pyfemtet.opt.optimizer.parameter import ExpressionEvaluator, Parameter
 
 # logger
 import logging
@@ -117,17 +116,11 @@ class AbstractOptimizer(ABC):
         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.
-        parameters (pd.DataFrame): The parameters used in the optimization.
-        objectives (dict): A dictionary containing the objective functions used in the optimization.
-        constraints (dict): A dictionary containing the constraint functions used in the optimization.
-        entire_status (OptimizationStatus): The status of the entire optimization process.
+        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.
-        worker_status (OptimizationStatus): The status of each worker in a distributed computing environment.
-        message (str): A message associated with the current state of the optimization process.
         seed (int or None): The random seed used for random number generation during the optimization process.
-        timeout (float or int or None): The maximum time allowed for each iteration of the optimization process. If exceeded, it will be interrupted and terminated early.
-        n_trials (int or None): The maximum number of trials allowed for each iteration of the optimization process. If exceeded, it will be interrupted and terminated early.
-        is_cluster (bool): Flag indicating if running on a distributed computing cluster.
 
     """
 
@@ -149,23 +142,46 @@ class AbstractOptimizer(ABC):
         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) -> list[np.ndarray]:
+        """Calculate objectives and constraints.
+
+        Args:
+            x (np.ndarray): Optimization parameters.
+
+        Returns:
+            list[np.ndarray]:
+                The list of internal objective values,
+                un-normalized objective values and
+                constraint values.
+
+        """
 
-    def f(self, x):
-        """Get x, update fem analysis, return objectives (and constraints)."""
-        # interruption の実装は具象クラスに任せる
 
         if isinstance(x, np.float64):
             x = np.array([x])
 
         # Optimizer の x の更新
         self.set_parameter_values(x)
-
-        logger.info('---------------------')
         logger.info(f'input: {x}')
 
         # FEM の更新
-        logger.debug('fem.update() start')
         try:
+            logger.info(f'Solving FEM...')
             df_to_fem = self.variables.get_variables(
                 format='df',
                 filter_pass_to_fem=True
@@ -176,25 +192,20 @@ class AbstractOptimizer(ABC):
             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.
+            raise e  # may be just a ModelError, etc. Handling them in Concrete classes.
 
         # y, _y, c の更新
-        logger.debug('calculate y start')
         y = [obj.calc(self.fem) for obj in self.objectives.values()]
 
-        logger.debug('calculate _y start')
         _y = [obj.convert(value) for obj, value in zip(self.objectives.values(), y)]
 
-        logger.debug('calculate c start')
         c = [cns.calc(self.fem) for cns in self.constraints.values()]
 
-        logger.debug('history.record start')
-
+        # register to history
         df_to_opt = self.variables.get_variables(
             format='df',
             filter_parameter=True,
         )
-
         self.history.record(
             df_to_opt,
             self.objectives,
@@ -202,36 +213,29 @@ class AbstractOptimizer(ABC):
             y,
             c,
             self.message,
-            postprocess_func=self.fem.postprocess_func,
-            postprocess_args=self.fem.create_postprocess_args(),
+            postprocess_func=self.fem._postprocess_func,
+            postprocess_args=self.fem._create_postprocess_args(),
         )
 
-        logger.debug('history.record end')
-
-        logger.info(f'output: {_y}')
+        logger.info(f'output: {y}')
 
         return np.array(y), np.array(_y), np.array(c)
 
-    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()
-
+    # ===== 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), 'value' (alias of values), 'values' (np.ndarray), or 'dict'. Defaults to 'dict'.
+            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:
-            object: The parameters in the specified format.
+            The parameters in the specified format.
 
         Raises:
             ValueError: If an invalid format is provided.
@@ -239,11 +243,14 @@ class AbstractOptimizer(ABC):
         """
         return self.variables.get_variables(format=format, filter_parameter=True)
 
-    def set_parameter(self, params: dict) -> None:
+    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.
+            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():
@@ -255,11 +262,25 @@ class AbstractOptimizer(ABC):
 
         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:
@@ -275,6 +296,7 @@ class AbstractOptimizer(ABC):
         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,
@@ -331,12 +353,16 @@ class AbstractOptimizer(ABC):
 
         return self._exception
 
-    @abstractmethod
-    def run(self) -> None:
-        """Start calculation using optimization library."""
-        pass
 
-    @abstractmethod
-    def _setup_before_parallel(self, *args, **kwargs):
-        """Setup before parallel processes are launched."""
-        pass
+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_botorchsampler_parameter_constraint_helper.py → _optuna/_botorch_patch/enable_nonlinear_constraint.py}

@@ -15,48 +15,14 @@ from botorch.optim.initializers import gen_batch_initial_conditions
 
 from pyfemtet.opt._femopt_core import Constraint
 from pyfemtet.opt.optimizer import OptunaOptimizer, logger
-from pyfemtet.message import Msg
+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)