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

pyfemtet/opt/history/_hypervolume.py

@@ -0,0 +1,169 @@
+# import
+from packaging import version
+
+import numpy as np
+import optuna
+if version.parse(optuna.version.__version__) < version.parse('4.0.0'):
+    # noinspection PyUnresolvedReferences
+    from optuna._hypervolume import WFG
+    wfg = WFG()
+    compute_hypervolume = wfg.compute
+else:
+    from optuna._hypervolume import wfg
+    compute_hypervolume = wfg.compute_hypervolume
+
+from ._optimality import *
+
+
+__all__ = [
+    'calc_hypervolume',
+]
+
+
+def calc_hypervolume(
+        y_internal: np.ndarray,
+        feasibility: np.ndarray,
+        ref_point: str | np.ndarray = 'nadir-up-to-the-point'
+) -> np.ndarray:
+    """
+
+    Args:
+        y_internal: n x m shaped 2d-array. float. Can contain nan.
+        feasibility: n shaped 1d-array. bool.
+        ref_point:
+            'nadir-up-to-the-point',
+            'worst-up-to-the-point',
+            'nadir',
+            'worst',
+            or the fixed reference point of y_internal.
+
+    Returns: n shaped 1d-array. float.
+
+    """
+
+    # single objective
+    if y_internal.shape[-1] == 1:
+        return np.full_like(np.empty(len(y_internal)), np.nan, dtype=float)
+
+    # multi objective
+    if isinstance(ref_point, str):
+        if ref_point.lower() == 'nadir-up-to-the-point':
+            hv_values = calc_hypervolume_nadir_up_to_the_point(y_internal, feasibility)
+        elif ref_point.lower() == 'worst-up-to-the-point':
+            hv_values = calc_hypervolume_worst_up_to_the_point(y_internal, feasibility)
+        elif ref_point.lower() == 'nadir':
+            hv = calc_hypervolume_nadir(y_internal, feasibility)
+            hv_values = hv * np.ones(len(y_internal)).astype(float)
+        elif ref_point.lower() == 'worst':
+            hv = calc_hypervolume_worst(y_internal, feasibility)
+            hv_values = hv * np.ones(len(y_internal)).astype(float)
+        else:
+            raise NotImplementedError
+
+    elif isinstance(ref_point, np.ndarray):
+        hv = calc_hypervolume_fixed_point(y_internal, feasibility, ref_point)
+        hv_values = hv * np.ones(len(y_internal)).astype(float)
+
+    else:
+        raise NotImplementedError
+
+    return hv_values
+
+
+def get_pareto_set(
+        y: np.ndarray,
+        feasibility: np.ndarray,
+) -> np.ndarray:
+    optimality = calc_optimality(y, feasibility)
+    non_dominated_solutions = y[optimality]
+    assert not np.any(np.isnan(non_dominated_solutions))
+    return non_dominated_solutions
+
+
+def calc_hypervolume_nadir(y, feasibility) -> float:
+    """Use Nadir point as the ref_point.
+
+    Args:
+        y: (n, m) shaped 2d-array. float.
+        feasibility (np.ndarray): n shaped 1d-array. bool.
+
+    Returns: float.
+
+    """
+
+    pareto_set = get_pareto_set(y, feasibility)
+    if len(pareto_set) == 0:
+        return 0.
+
+    nadir_point = pareto_set.max(axis=0)
+    ref_point = nadir_point + 1e-8
+    hv = compute_hypervolume(pareto_set, ref_point)
+
+    return hv
+
+
+def calc_hypervolume_nadir_up_to_the_point(y, feasibility) -> np.ndarray:
+    """Use Nadir point up_to_the_point as the ref_point.
+
+    Args:
+        y: (n, m) shaped 2d-array. float.
+        feasibility (np.ndarray): n shaped 1d-array. bool.
+
+    Returns: (n) shaped 1d-array. float.
+
+    """
+
+    out = []
+
+    assert len(y) == len(feasibility)
+    for n in range(len(y)):
+        y_up = y[:n]
+        f_up = feasibility[:n]
+        out.append(calc_hypervolume_nadir(y_up, f_up))
+
+    return np.array(out).astype(float)
+
+
+def calc_hypervolume_worst(y, feasibility) -> float:
+    """Use Worst point as the ref_point.
+
+    Args:
+        y: (n, m) shaped 2d-array. float.
+        feasibility (np.ndarray): n shaped 1d-array. bool.
+
+    Returns: float.
+
+    """
+
+    feasible_solutions = y[feasibility]
+    if len(feasible_solutions) == 0:
+        return 0.
+
+    worst_point = feasible_solutions.max(axis=0)
+    ref_point = worst_point + 1e-8
+    hv = compute_hypervolume(feasible_solutions, ref_point)
+
+    return hv
+
+
+def calc_hypervolume_worst_up_to_the_point(y, feasibility) -> np.ndarray:
+    out = []
+
+    assert len(y) == len(feasibility)
+    for n in range(len(y)):
+        y_up = y[:n]
+        f_up = feasibility[:n]
+        out.append(calc_hypervolume_worst(y_up, f_up))
+
+    return np.array(out).astype(float)
+
+
+def calc_hypervolume_fixed_point(y, feasibility, ref_point) -> float:
+
+    feasible_solutions = y[feasibility]
+    if len(feasible_solutions) == 0:
+        return 0.
+
+    hv = compute_hypervolume(feasible_solutions, ref_point)
+
+    return hv

pyfemtet/opt/history/_optimality.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+
+__all__ = ['calc_optimality']
+
+
+def calc_optimality(y_internal: np.ndarray, feasibility: np.ndarray) -> np.ndarray:
+    """
+
+    Args:
+        y_internal (np.ndarray): n x m shaped 2d-array. Can contain np.nan. Minimum value is optimal.
+        feasibility (np.ndarray): n shaped 1d-array. bool.
+
+    Returns:
+        np.ndarray: Array if not optimal, dominated or Nan False, else True
+
+    """
+
+    # 「全ての項目において
+    # 重複する解を除いて
+    # より優れているか又は同等である
+    # 他の解が存在しない解」であるかどうかを判定
+    y_values: np.ndarray
+    another_y_values: np.ndarray
+    optimality = []
+    assert len(y_internal) == len(feasibility)
+    for i, (y_values, feas) in enumerate(zip(y_internal, feasibility)):
+        for j, (another_y_values, another_feas) in enumerate(zip(y_internal, feasibility)):
+
+            # 自身が infeasible なら
+            # 比較を終了して False
+            if not feas:
+                optimality.append(False)
+                break
+
+            # 比較相手が infeasible なら
+            # 比較しない
+            elif not another_feas:
+                continue
+
+            # 自身との比較はしない
+            elif i == j:
+                continue
+
+            # 重複した解なら比較しない
+            elif np.allclose(y_values, another_y_values, atol=0, rtol=0.01):
+                assert np.all(~np.isnan(y_values))
+                assert np.all(~np.isnan(another_y_values))
+                continue
+
+            # 全項目について another のほうが
+            # 優れているか又は同等であるなら
+            # 比較を終了して False
+            elif all(another_y_values <= y_values):
+                optimality.append(False)
+                break
+
+            # その他の場合、比較を続行
+            else:
+                pass
+
+        # 自身以外のすべての解と比較して
+        # optimality が False になるような
+        # ことがなかったので True
+        else:
+            optimality.append(True)
+
+    return np.array(optimality).astype(bool)
+
+
+if __name__ == '__main__':
+    _optimality = calc_optimality(
+        (_y := np.random.rand(10, 2)),
+        (_feas := (np.random.rand(10) > 0.25).astype(bool))
+    )
+
+    print(_y)
+    print(_feas)
+    print(_optimality)

pyfemtet/opt/interface/__init__.py

@@ -1,37 +1,30 @@
 import platform
-from typing import TYPE_CHECKING
 
-from pyfemtet.opt.interface._base import FEMInterface
-from pyfemtet.opt.interface._base import NoFEM
+from ._base_interface import AbstractFEMInterface, NoFEM
 
-if (platform.system() == 'Windows') or TYPE_CHECKING:
-    from pyfemtet.opt.interface._femtet import FemtetInterface
-    from pyfemtet.opt.interface._femtet_with_sldworks import FemtetWithSolidworksInterface
-    from pyfemtet.opt.interface._femtet_with_nx import FemtetWithNXInterface
-    from pyfemtet.opt.interface._excel_interface import ExcelInterface
+if platform.system() == 'Windows':
+    from ._femtet_interface import FemtetInterface
+    from ._femtet_with_nx_interface import FemtetWithNXInterface
+    from ._femtet_with_solidworks import FemtetWithSolidworksInterface
+    from ._excel_interface import ExcelInterface
+    from ._with_excel_settings import *
+    from ._with_excel_settings import __all__ as _with_excel_settings__all__
 
-else:
-    class NotAvailableForWindows:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError
-
-
-    FemtetInterface = type('FemtetInterface', (NotAvailableForWindows,), {})
-    FemtetWithSolidworksInterface = type('FemtetWithSolidworksInterface', (FemtetInterface,), {})
-    FemtetWithNXInterface = type('FemtetWithNXInterface', (FemtetInterface,), {})
-    ExcelInterface = type('ExcelInterface', (NotAvailableForWindows,), {})
-
-from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
-from pyfemtet.opt.interface._surrogate._singletaskgp import PoFBoTorchInterface
+from ._surrogate_model_interface import AbstractSurrogateModelInterfaceBase
+from ._surrogate_model_interface import BoTorchInterface
+from ._surrogate_model_interface import PoFBoTorchInterface
 
 
 __all__ = [
-    'FEMInterface',
+    'AbstractFEMInterface',
     'NoFEM',
     'FemtetInterface',
-    'FemtetWithSolidworksInterface',
     'FemtetWithNXInterface',
+    'FemtetWithSolidworksInterface',
     'ExcelInterface',
-    'SurrogateModelInterfaceBase',
+    'AbstractSurrogateModelInterfaceBase',
+    'BoTorchInterface',
     'PoFBoTorchInterface',
 ]
+
+__all__.extend(_with_excel_settings__all__)

pyfemtet/opt/interface/_base_interface.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import os
+import tempfile
+
+import shutil
+import pandas as pd
+
+try:
+    # noinspection PyUnresolvedReferences
+    from pythoncom import CoInitialize, CoUninitialize
+    from win32com.client import Dispatch, Constants, constants
+except ModuleNotFoundError:
+    # noinspection PyPep8Naming
+    def CoInitialize(): ...
+    # noinspection PyPep8Naming
+    def CoUninitialize(): ...
+    Dispatch = type('NoDispatch', (object,), {})
+    Constants = type('NoConstants', (object,), {})
+    constants = Constants()
+
+from pyfemtet._util.dask_util import *
+from pyfemtet.logger import get_module_logger
+from pyfemtet.opt.problem.variable_manager import SupportedVariableTypes
+
+logger = get_module_logger('opt.interface', False)
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+
+__all__ = [
+    'AbstractFEMInterface',
+    'NoFEM',
+]
+
+
+class AbstractFEMInterface:
+
+    kwargs: dict = {}
+    _load_problem_from_fem: bool = False
+    current_prm_values: dict[str, SupportedVariableTypes]
+    _tmp_dir: tempfile.TemporaryDirectory
+
+    # ===== update =====
+
+    def update_parameter(self, x: dict[str, SupportedVariableTypes]) -> None:
+        # FEM オブジェクトに与えられた変数を設定する。
+        #   目的は Function 内でユーザーが FEM オブジェクト経由で
+        #   変数を取得できるようにするためなので、各具象クラスでは
+        #   FEM オブジェクトから新しい変数を取得できるように
+        #   することが望ましい
+        self.current_prm_values = x
+
+    def update(self) -> None:
+        # 現在の設計変数に基づいて solve を行い、
+        # Objective が正しく値を計算できるようにする
+        raise NotImplementedError
+
+    # ===== Function =====
+
+    @property
+    def object_pass_to_fun(self):
+        """The object pass to the first argument of user-defined objective functions.
+
+        Returns:
+            self (AbstractFEMInterface)
+        """
+        return self
+
+    # ===== dask util =====
+
+    @staticmethod
+    def _get_worker_index_from_optimizer(opt: AbstractOptimizer | None) -> str:
+        if opt is None:
+            worker_index = 'copy'
+        else:
+            worker_index = f'copy_{opt._worker_index}' if opt._worker_index is not None else 'copy'
+        return worker_index
+
+    def _rename_and_get_path_on_worker_space(self, orig_path, suffix, ignore_no_exist=False) -> str:
+        # 与えられた path と同名のファイルを
+        # worker_space から探し
+        # suffix を付与して rename し
+        # その renamed path を返す関数
+
+        worker_space = self._get_worker_space()
+
+        src_path = os.path.join(worker_space, os.path.basename(orig_path))
+        p1_, p2_ = os.path.splitext(src_path)
+        dst_path_ = p1_ + '_' + suffix + p2_
+
+        if os.path.isfile(src_path):
+            os.rename(src_path, dst_path_)
+
+        elif not ignore_no_exist:
+            raise FileNotFoundError(f'{src_path} is not found.')
+
+        return dst_path_
+
+    def _get_worker_space(self) -> str | None:
+        worker = get_worker()
+        if worker is None:
+            assert hasattr(self, '_tmp_dir'), 'Internal Error! Run _distribute_files() first!'
+            return self._tmp_dir.name
+        else:
+            return worker.local_directory
+
+    def _distribute_files(self, paths: list[str]) -> None:
+
+        # executor 向け
+        self._copy_to_temp_space(paths)
+
+        # dask worker 向け
+        client = get_client()
+        if client is not None:
+            for path in paths:
+                if not os.path.exists(path):
+                    raise FileNotFoundError
+                client.upload_file(path, load=False)
+
+    def _verify_tmp_dir(self):
+        should_process = False
+
+        if not hasattr(self, '_tmp_dir'):
+            should_process = True
+
+        elif self._tmp_dir is None:
+            should_process = True
+
+        if not should_process:
+            return
+
+        # dask worker space のように使える一時フォルダを作成する
+        # Python プロセス終了時に（使用中のプロセスがなければ）
+        # 削除されるので、重大なものでなければ後処理は不要
+        tmp_dir = tempfile.TemporaryDirectory(prefix='pyfemtet-')
+        self._tmp_dir = tmp_dir
+
+    def _copy_to_temp_space(self, paths: list[str]) -> None:
+
+        self._verify_tmp_dir()
+
+        # client.upload_file 相当の処理を行う
+        for path in paths:
+            shutil.copy(path, self._tmp_dir.name)
+
+    # ===== setup =====
+
+    def _setup_before_parallel(self) -> None:
+        pass
+
+    def _setup_after_parallel(self, opt: AbstractOptimizer) -> None:
+        pass
+
+    def _check_param_and_raise(self, prm_name) -> None:
+        pass
+
+    def load_variables(self, opt: AbstractOptimizer):
+        pass
+
+    def load_objectives(self, opt: AbstractOptimizer):
+        pass
+
+    def load_constraints(self, opt: AbstractOptimizer):
+        pass
+
+    def close(self, *args, **kwargs):  # context manager による予約語
+        pass
+
+    # noinspection PyMethodMayBeStatic,PyUnusedLocal
+    def _check_using_fem(self, fun: callable) -> bool:
+        return False
+
+    # ===== postprocessing after recording =====
+
+    def _create_postprocess_args(self) -> dict[str, ...]:
+        return {}
+
+    @staticmethod
+    def _postprocess_after_recording(
+            dask_scheduler,
+            trial_name: str,
+            df: pd.DataFrame,
+            **kwargs
+    ) -> ...:  # _postprocess_after_recording
+        pass
+
+    # ===== others =====
+
+    # noinspection PyMethodMayBeStatic
+    def _get_additional_data(self) -> dict:
+        return dict()
+
+
+class COMInterface(AbstractFEMInterface):
+
+    com_members = {}
+
+    def __getstate__(self):
+        """Pickle するメンバーから COM を除外する"""
+        state = self.__dict__.copy()
+        for key in self.com_members.keys():
+            del state[key]
+        return state
+
+    def __setstate__(self, state):
+        """UnPickle 時に COM を再構築する
+
+        ただしメインプロセスでしか呼ばれない模様
+        dask のバージョン依存？
+        """
+        CoInitialize()
+        for key, value in self.com_members.items():
+            state.update({key: Dispatch(value)})
+        self.__dict__.update(state)
+
+
+class NoFEM(AbstractFEMInterface):
+
+    def update(self) -> None:
+        return None

pyfemtet/opt/interface/_excel_interface/__init__.py

@@ -0,0 +1,3 @@
+from .excel_interface import ExcelInterface
+
+__all__ = ['ExcelInterface']