pyfemtet 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

pyfemtet/opt/interface/_femtet.py

@@ -49,6 +49,10 @@ def _post_activate_message(hwnd):
     win32gui.PostMessage(hwnd, win32con.WM_ACTIVATE, win32con.WA_ACTIVE, 0)
 
 
+class FailedToPostProcess(Exception):
+    pass
+
+
 class FemtetInterface(FEMInterface):
     """Control Femtet from optimizer.
 
@@ -86,10 +90,6 @@ class FemtetInterface(FEMInterface):
             it will be None and no parametric outputs are used
             as objectives.
 
-        confirm_before_exit (bool):
-            Whether to confirm before (abnormal) termination.
-            Default is True.
-
         **kwargs: Additional arguments from inherited classes.
 
     Warning:
@@ -115,7 +115,6 @@ class FemtetInterface(FEMInterface):
             allow_without_project: bool = False,  # main でのみ True を許容したいので super() の引数にしない。
             open_result_with_gui: bool = True,
             parametric_output_indexes_use_as_objective: dict[int, str or float] = None,
-            confirm_before_exit: bool = True,
             **kwargs  # 継承されたクラスからの引数
     ):
 
@@ -145,7 +144,6 @@ class FemtetInterface(FEMInterface):
         self.parametric_output_indexes_use_as_objective = parametric_output_indexes_use_as_objective
         self._original_autosave_enabled = _get_autosave_enabled()
         _set_autosave_enabled(False)
-        self.confirm_before_exit = confirm_before_exit
 
         # dask サブプロセスのときは femprj を更新し connect_method を new にする
         try:
@@ -183,14 +181,11 @@ class FemtetInterface(FEMInterface):
             open_result_with_gui=self.open_result_with_gui,
             parametric_output_indexes_use_as_objective=self.parametric_output_indexes_use_as_objective,
             save_pdt=self.save_pdt,
-            confirm_before_exit=self.confirm_before_exit,
             **kwargs
         )
 
     def __del__(self):
-        _set_autosave_enabled(self._original_autosave_enabled)
-        if self.quit_when_destruct:
-            self.quit()
+        self.quit()
         # CoUninitialize()  # Win32 exception occurred releasing IUnknown at 0x0000022427692748
 
     def _connect_new_femtet(self):
@@ -253,11 +248,9 @@ class FemtetInterface(FEMInterface):
             cmd = f'{sys.executable} -m win32com.client.makepy FemtetMacro'
             os.system(cmd)
             message = Msg.ERR_NO_MAKEPY
-            print('================')
-            print(message)
-            print('================')
-            if self.confirm_before_exit:
-                input('Press enter to finish...')
+            logger.error('================')
+            logger.error(message)
+            logger.error('================')
             raise RuntimeError(message)
 
         if self.Femtet is None:
@@ -541,24 +534,20 @@ class FemtetInterface(FEMInterface):
             try:
                 variable_names = self.Femtet.GetVariableNames_py()
             except AttributeError as e:
-                print('================')
+                logger.error('================')
                 logger.error(Msg.ERR_CANNOT_ACCESS_API + 'GetVariableNames_py')
                 logger.error(Msg.CERTIFY_MACRO_VERSION)
-                print('================')
-                if self.confirm_before_exit:
-                    input(Msg.ENTER_TO_QUIT)
+                logger.error('================')
                 raise e
                 
             if variable_names is not None:
                 if param_name in variable_names:
                     return self.Femtet.GetVariableValue(param_name)
             message = Msg.ERR_NO_SUCH_PARAMETER_IN_FEMTET
-            print('================')
+            logger.error('================')
             logger.error(message)
             logger.error(f'`{param_name}` not in {variable_names}')
-            print('================')
-            if self.confirm_before_exit:
-                input(Msg.ENTER_TO_QUIT)
+            logger.error('================')
             raise RuntimeError(message)
         else:
             return None
@@ -739,7 +728,8 @@ class FemtetInterface(FEMInterface):
 
         _set_autosave_enabled(self._original_autosave_enabled)
 
-        _exit_or_force_terminate(timeout=timeout, Femtet=self.Femtet, force=True)
+        if self.quit_when_destruct:
+            _exit_or_force_terminate(timeout=timeout, Femtet=self.Femtet, force=True)
 
     def _setup_before_parallel(self, client):
         client.upload_file(
@@ -751,8 +741,15 @@ class FemtetInterface(FEMInterface):
         return _version(Femtet=self.Femtet)
 
     def _create_postprocess_args(self):
-        file_content = self._create_result_file_content()
-        jpg_content = self._create_jpg_content()
+        try:
+            file_content = self._create_result_file_content()
+        except FailedToPostProcess:
+            file_content = None
+
+        try:
+            jpg_content = self._create_jpg_content()
+        except FailedToPostProcess:
+            jpg_content = None
 
         out = dict(
             original_femprj_path=self.original_femprj_path,
@@ -800,7 +797,7 @@ class FemtetInterface(FEMInterface):
                 fun=self.Femtet.SavePDT,
                 args=(pdt_path, True),
                 return_value_if_failed=False,
-                if_error=SolveError,
+                if_error=FailedToPostProcess,
                 error_message=Msg.ERR_FAILED_TO_SAVE_PDT,
                 is_Gaudi_method=False,
             )
@@ -828,10 +825,10 @@ class FemtetInterface(FEMInterface):
         self.Femtet.RedrawMode = True  # 逐一の描画をオン
 
         if not succeed:
-            raise Exception(Msg.ERR_FAILED_TO_SAVE_JPG)
+            raise FailedToPostProcess(Msg.ERR_FAILED_TO_SAVE_JPG)
 
         if not os.path.exists(jpg_path):
-            raise Exception(Msg.ERR_JPG_NOT_FOUND)
+            raise FailedToPostProcess(Msg.ERR_JPG_NOT_FOUND)
 
         with open(jpg_path, 'rb') as f:
             content = f.read()

pyfemtet/opt/interface/_surrogate/__init__.py

@@ -0,0 +1,5 @@
+from pyfemtet.opt.interface._surrogate._singletaskgp import PoFBoTorchInterface
+
+__all__ = [
+    PoFBoTorchInterface,
+]

pyfemtet/opt/interface/_surrogate/_base.py

@@ -0,0 +1,85 @@
+from typing import Optional, List, Any
+from abc import ABC
+
+import numpy as np
+import pandas as pd
+
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt._femopt_core import History, Objective
+from pyfemtet.opt.interface._base import FEMInterface
+from pyfemtet.opt.optimizer._base import AbstractOptimizer
+
+logger = get_module_logger('opt.interface', __name__)
+
+
+class SurrogateModelInterfaceBase(FEMInterface, ABC):
+    def __init__(
+            self,
+            history_path: str = None,
+            history: History = None,
+    ):
+
+        self.history: History
+        self.model: Any
+        self.prm: dict[str, float] = dict()
+        self.obj: dict[str, float] = dict()
+        self.df_prm: pd.DataFrame
+        self.df_obj: pd.DataFrame
+
+        # history_path が与えられた場合、history をコンストラクトする
+        if history_path is not None:
+            history = History(history_path=history_path)
+
+        # history が与えられるかコンストラクトされている場合
+        if history is not None:
+            # 学習データを準備する
+            df_prm = history.get_df()[history.prm_names]
+            df_obj = history.get_df()[history.obj_names]
+
+            # obj の名前を作る
+            for obj_name in history.obj_names:
+                self.obj[obj_name] = np.nan
+
+            # prm の名前を作る
+            for prm_name in history.prm_names:
+                self.prm[prm_name] = np.nan
+
+            self.history = history
+
+        # history から作らない場合、引数チェック
+        else:
+            # assert len(train_x) == len(train_y)
+            raise NotImplementedError
+
+        self.df_prm = df_prm
+        self.df_obj = df_obj
+
+        FEMInterface.__init__(
+            self,
+            history=history,  # コンストラクト済み history を渡せば並列計算時も何もしなくてよい
+        )
+
+    def filter_feasible(self, x: np.ndarray, y: np.ndarray, return_feasibility=False):
+        feasible_idx = np.where(~np.isnan(y.sum(axis=1)))
+        if return_feasibility:
+            # calculated or not
+            y = np.zeros_like(y)
+            y[feasible_idx] = 1.
+            # satisfy weak feasibility or not
+            infeasible_idx = np.where(~self.history.get_df()['feasible'].values)
+            y[infeasible_idx] = .0
+            return x, y.reshape((-1, 1))
+        else:
+            return x[feasible_idx], y[feasible_idx]
+
+    def _setup_after_parallel(self, *args, **kwargs):
+
+        opt: AbstractOptimizer = kwargs['opt']
+        obj: Objective
+        for obj_name, obj in opt.objectives.items():
+            obj.fun = lambda: self.obj[obj_name]
+
+    def update_parameter(self, parameters: pd.DataFrame, with_warning=False) -> Optional[List[str]]:
+        for i, row in parameters.iterrows():
+            name, value = row['name'], row['value']
+            self.prm[name] = value

pyfemtet/opt/interface/_surrogate/_chaospy.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pandas as pd
+
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
+from pyfemtet.opt.prediction.polynomial_expansion import PolynomialExpansionModel
+
+
+logger = get_module_logger('opt.interface', __name__)
+
+
+class PolynomialChaosInterface(SurrogateModelInterfaceBase):
+
+    model: PolynomialExpansionModel  # surrogate_func_expansion
+
+    def train(self):
+        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values)
+        assert len(x) > 0, 'No feasible results in training data.'
+        self.model.fit(x, y)
+
+    def _setup_after_parallel(self, *args, **kwargs):
+
+        # # update objectives
+        # SurrogateModelInterfaceBase._setup_after_parallel(
+        #     self, *args, **kwargs
+        # )
+
+        # train model
+        self.model = PolynomialExpansionModel()
+        self.model.set_bounds_from_history(self.history)
+        self.train()
+
+    def update(self, parameters: pd.DataFrame) -> None:
+        # self.prm 更新
+        SurrogateModelInterfaceBase.update_parameter(
+            self, parameters
+        )
+
+        # history.prm_name 順に並べ替え
+        x = np.array([self.prm[k] for k in self.history.prm_names])
+
+        # prediction
+        dist_mean, _ = self.model.predict(x)
+
+        # 目的関数の更新
+        self.obj = {obj_name: value for obj_name, value in zip(self.history.obj_names, dist_mean)}
+
+
+if __name__ == '__main__':
+    import os
+    from pyfemtet.opt._femopt_core import History
+
+    os.chdir(os.path.dirname(__file__))
+
+    history = History(history_path='sample.csv')
+    fem = PolynomialChaosInterface(history=history)
+
+    import pandas as pd
+    df = history.get_df()
+    parameters = pd.DataFrame(
+        dict(
+            name=history.prm_names,
+            value=[1. for _ in history.prm_names]
+        )
+    )
+
+    fem._setup_after_parallel()
+
+    fem.update(
+        parameters
+    )

pyfemtet/opt/interface/_surrogate/_singletaskgp.py

@@ -0,0 +1,70 @@
+import numpy as np
+import pandas as pd
+from scipy.stats.distributions import norm
+
+from pyfemtet.core import SolveError
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
+from pyfemtet.opt.prediction.single_task_gp import SingleTaskGPModel
+
+from pyfemtet._message.messages import Message as Msg
+
+
+logger = get_module_logger('opt.interface', __name__)
+
+
+class PoFBoTorchInterface(SurrogateModelInterfaceBase):
+    model_f: SingleTaskGPModel
+    model: SingleTaskGPModel
+    threshold = 0.5
+
+    def train(self):
+        # df そのまま用いて training する
+        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values)
+        assert len(x) > 0, 'No feasible results in training data.'
+        self.model.fit(x, y)
+
+    def train_f(self):
+        # df そのまま用いて training する
+        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values, return_feasibility=True)
+        if y.min() == 1:
+            self.model_f.predict = lambda *args, **kwargs: (1., 0.001)
+        self.model_f.fit(x, y)
+
+    def _setup_after_parallel(self, *args, **kwargs):
+
+        # update objectives
+        SurrogateModelInterfaceBase._setup_after_parallel(
+            self, *args, **kwargs
+        )
+
+        # model training
+        self.model = SingleTaskGPModel()
+        self.model.set_bounds_from_history(self.history)
+        self.train()
+
+        # model_f training
+        self.model_f = SingleTaskGPModel(is_noise_free=False)
+        self.model_f.set_bounds_from_history(self.history)
+        self.train_f()
+
+    def update(self, parameters: pd.DataFrame) -> None:
+        # self.prm 更新
+        SurrogateModelInterfaceBase.update_parameter(
+            self, parameters
+        )
+
+        # history.prm_name 順に並べ替え
+        x = np.array([self.prm[k] for k in self.history.prm_names])
+
+        # feasibility の計算
+        mean_f, std_f = self.model_f.predict(np.array([x]))
+        pof = 1. - norm.cdf(self.threshold, loc=mean_f, scale=std_f)
+        if pof < self.threshold:
+            raise SolveError(Msg.INFO_POF_IS_LESS_THAN_THRESHOLD)
+
+        # 実際の計算(mean は history.obj_names 順)
+        mean, _ = self.model.predict(np.array([x]))
+
+        # 目的関数の更新
+        self.obj = {obj_name: value for obj_name, value in zip(self.history.obj_names, mean)}

pyfemtet/opt/optimizer/_base.py

@@ -155,12 +155,18 @@ class AbstractOptimizer(ABC):
         """Setup before parallel processes are launched."""
         pass
 
+    def generate_infeasible_result(self):
+        y = np.full_like(np.zeros(len(self.objectives)), np.nan)
+        c = np.full_like(np.zeros(len(self.constraints)), np.nan)
+        return y, y, c
+
     # ===== calc =====
-    def f(self, x: np.ndarray) -> list[np.ndarray]:
+    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]:
@@ -178,27 +184,31 @@ class AbstractOptimizer(ABC):
         self.set_parameter_values(x)
         logger.info(f'input: {x}')
 
-        # 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)
+        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.
+            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, _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)]
+            _y = [obj.convert(value) for obj, value in zip(self.objectives.values(), y)]
 
-        c = [cns.calc(self.fem) for cns in self.constraints.values()]
+            c = [cns.calc(self.fem) for cns in self.constraints.values()]
+
+        else:
+            y, _y, c = self.generate_infeasible_result()
 
         # register to history
         df_to_opt = self.variables.get_variables(
@@ -302,6 +312,7 @@ class AbstractOptimizer(ABC):
             worker_status_list,  # 他の worker の status オブジェクト
             wait_setup,  # 他の worker の status が ready になるまで待つか
             skip_reconstruct=False,  # reconstruct fem を行うかどうか
+            space_dir=None,  # 特定の space_dir を使うかどうか
     ) -> Optional[Exception]:
 
         # 自分の worker_status の取得
@@ -314,7 +325,7 @@ class AbstractOptimizer(ABC):
 
         # set_fem をはじめ、終了したらそれを示す
         self._reconstruct_fem(skip_reconstruct)
-        self.fem._setup_after_parallel(opt=self)
+        self.fem._setup_after_parallel(opt=self, space_dir=space_dir)
         self.worker_status.set(OptimizationStatus.WAIT_OTHER_WORKERS)
 
         # wait_setup or not

pyfemtet/opt/optimizer/_optuna/_optuna.py

@@ -4,6 +4,7 @@ from typing import Iterable
 # built-in
 import os
 import inspect
+import gc
 
 # 3rd-party
 import optuna
@@ -92,10 +93,7 @@ class OptunaOptimizer(AbstractOptimizer):
     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 =====')
+        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:
@@ -124,6 +122,7 @@ class OptunaOptimizer(AbstractOptimizer):
         # 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]
@@ -140,10 +139,11 @@ class OptunaOptimizer(AbstractOptimizer):
                 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.
 
         # 計算
-        x = self.variables.get_variables(format='values', filter_parameter=True)
         try:
             _, _y, c = self.f(x)  # f の中で info は出している
         except (ModelError, MeshError, SolveError) as e:
@@ -162,6 +162,8 @@ class OptunaOptimizer(AbstractOptimizer):
                            '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 の更新
@@ -284,8 +286,19 @@ class OptunaOptimizer(AbstractOptimizer):
             from optuna.samplers import TPESampler
             if issubclass(self.sampler_class, TPESampler):
 
-                if os.path.exists(self._temporary_storage_path):
-                    os.remove(self._temporary_storage_path)
+                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}',
@@ -403,7 +416,6 @@ class OptunaOptimizer(AbstractOptimizer):
                 self._temporary_storage.remove_session()
                 del self._temporary_storage
                 del _study
-                import gc
                 gc.collect()
                 if os.path.exists(self._temporary_storage_path):
                     os.remove(self._temporary_storage_path)