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

pyfemtet/opt/interface/_with_excel_settings/__init__.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeAlias
+
+import platform
+
+
+__all__ = []  # appended later
+
+
+if platform.system() == 'Windows':
+
+    from pyfemtet.opt.interface._excel_interface import ExcelInterface
+
+    from pyfemtet.opt.interface._femtet_interface import FemtetInterface
+    from pyfemtet.opt.interface._femtet_with_nx_interface import FemtetWithNXInterface
+    from pyfemtet.opt.interface._femtet_with_solidworks import FemtetWithSolidworksInterface
+
+    from .with_excel_settings import _class_factory
+
+    if TYPE_CHECKING:
+        class FemtetWithExcelSettingsInterface(FemtetInterface, ExcelInterface):
+            init_excel = ExcelInterface
+    else:
+        FemtetWithExcelSettingsInterface = _class_factory(FemtetInterface)
+    __all__.append('FemtetWithExcelSettingsInterface')
+
+    if TYPE_CHECKING:
+        class FemtetWithNXWithExcelSettingsInterface(FemtetWithNXInterface, ExcelInterface):
+            def init_excel(self, *args, **kwargs):
+                pass
+    else:
+        FemtetWithNXWithExcelSettingsInterface = _class_factory(FemtetWithNXInterface)
+    __all__.append('FemtetWithNXWithExcelSettingsInterface')
+
+    if TYPE_CHECKING:
+        class FemtetWithSolidworksWithExcelSettingsInterface(FemtetWithSolidworksInterface, ExcelInterface):
+            def init_excel(self, *args, **kwargs):
+                pass
+    else:
+        FemtetWithSolidworksWithExcelSettingsInterface = _class_factory(FemtetWithSolidworksInterface)
+    __all__.append('FemtetWithSolidworksWithExcelSettingsInterface')
+
+
+from pyfemtet.opt.interface._surrogate_model_interface import BoTorchInterface, PoFBoTorchInterface
+
+if TYPE_CHECKING:
+    class BoTorchWithExcelSettingsInterface(BoTorchInterface, ExcelInterface):
+        def init_excel(self, *args, **kwargs):
+            pass
+else:
+    BoTorchWithExcelSettingsInterface = _class_factory(BoTorchInterface)
+__all__.append('BoTorchWithExcelSettingsInterface')
+
+if TYPE_CHECKING:
+    class PoFBoTorchWithExcelSettingsInterface(PoFBoTorchInterface, ExcelInterface):
+        def init_excel(self, *args, **kwargs):
+            pass
+else:
+    PoFBoTorchWithExcelSettingsInterface = _class_factory(PoFBoTorchInterface)
+__all__.append('PoFBoTorchWithExcelSettingsInterface')

pyfemtet/opt/interface/_with_excel_settings/with_excel_settings.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import re
+
+from pyfemtet.opt.problem.problem import SupportedVariableTypes
+from pyfemtet.opt.interface._base_interface import AbstractFEMInterface
+from pyfemtet.opt.interface._excel_interface import ExcelInterface
+from pyfemtet.opt.interface._femtet_interface import FemtetInterface
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+
+
+def _get_name(FEMClass: type):
+    return FEMClass.__name__.removesuffix('Interface') + 'WithExcelSettingsInterface'
+
+
+def _is_parametric_output(obj_name: str) -> bool:
+    if obj_name.startswith('パラメトリック結果出力'):
+        return True
+
+    return False
+
+
+class ParametricNumberNotFoundError(Exception):
+    pass
+
+
+def _get_parametric_output_number(obj_name: str) -> int:
+    # 最後のマッチを取得
+    matches = re.findall(r'\d+', obj_name)
+
+    if matches:
+        last_match = matches[-1]
+        return int(last_match)
+
+    else:
+        raise ParametricNumberNotFoundError(
+            'Excel の設定シートからパラメトリック結果出力機能を'
+            '使うことを意図した目的名が検出されましたが、'
+            '出力番号が取得できませんでした。目的名には、'
+            'パラメトリック結果出力番号を表す自然数を含めてください。'
+            '例：「パラメトリック結果出力 1 番」')
+
+
+def _class_factory(FEMClass: type[AbstractFEMInterface]) -> type[AbstractFEMInterface]:
+
+    class _WithExcelSettingsInterface(FEMClass, ExcelInterface):
+
+        __name__ = _get_name(FEMClass=FEMClass)
+
+        # 構造が複雑で型ヒントが働かないため
+        _excel_initialized: bool
+        _load_problem_from_fem: bool
+
+        def init_excel(self, *args, **kwargs):
+            ExcelInterface.__init__(self, *args, **kwargs)
+            self._excel_initialized = True
+            self._load_problem_from_fem = True
+
+        def _setup_before_parallel(self):
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface._setup_before_parallel(self)
+            FEMClass._setup_before_parallel(self)
+
+        def _setup_after_parallel(self, opt: AbstractOptimizer):
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface._setup_after_parallel(self, opt)
+            FEMClass._setup_after_parallel(self, opt)
+
+        def load_variable(self, opt: AbstractOptimizer, raise_if_no_keyword=True) -> None:
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface.load_variables(self, opt, raise_if_no_keyword)
+            FEMClass.load_variables(self, opt)
+
+        def load_objectives(self, opt: AbstractOptimizer, raise_if_no_keyword=False) -> None:
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface.load_objectives(self, opt, raise_if_no_keyword)
+
+            # FEMClass が FemtetInterface なら
+            #   この時点での objectives を列挙して
+            #   「パラメトリック」から始まる目的関数を
+            #   削除して parametric 結果出力の
+            #   それに置き換える
+            if isinstance(self, FemtetInterface):
+
+                # 削除すべき obj を取得
+                obj_names_to_replace = []
+                for obj_name in opt.objectives.keys():
+                    if _is_parametric_output(obj_name):
+                        obj_names_to_replace.append(obj_name)
+
+                # 削除と置換の予約
+                for old_obj_name in obj_names_to_replace:
+
+                    # 削除
+                    old_obj = opt.objectives.pop(old_obj_name)
+
+                    # 追加すべき内容の決定
+                    self: FemtetInterface
+                    self.use_parametric_output_as_objective(
+                        number=_get_parametric_output_number(old_obj_name),
+                        direction=old_obj.direction,
+                    )
+
+                # parametric 結果出力の追加の実行
+                FemtetInterface.load_objectives(self, opt)
+
+            else:
+                FEMClass.load_objectives(self, opt)
+
+        def load_constraints(self, opt: AbstractOptimizer, raise_if_no_keyword=False) -> None:
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface.load_constraints(self, opt, raise_if_no_keyword)
+            FEMClass.load_constraints(self, opt)
+
+        def update_parameter(self, x: SupportedVariableTypes) -> None:
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface.update_parameter(self, x)
+            FEMClass.update_parameter(self, x)
+
+        def update(self) -> None:
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface.update(self)
+            FEMClass.update(self)
+
+        def close(self):
+            assert self._excel_initialized, '最初に init_excel() を呼び出してください。'
+            ExcelInterface.close(self)
+            FEMClass.close(self)
+
+    return _WithExcelSettingsInterface

pyfemtet/opt/meta_script/__main__.py

@@ -11,7 +11,7 @@ try:
     if __name__ == '__main__':
         print(f'pyfemtet {pyfemtet.__version__} starting.')
 
-    from pyfemtet._message.messages import encoding
+    from pyfemtet._i18n import ENCODING
 
     from fire import Fire
     import yaml
@@ -21,11 +21,6 @@ try:
     from pyfemtet.opt import FEMOpt
     from pyfemtet.opt.interface import *
     from pyfemtet.opt.optimizer import *
-    from pyfemtet.opt.interface._femtet_excel import FemtetWithExcelSettingsInterface
-    from pyfemtet.opt.interface._surrogate_excel import PoFBoTorchInterfaceWithExcelSettingsInterface
-
-    # for debug
-    DEBUG = False
 
     class ContentContext:
 
@@ -62,13 +57,12 @@ try:
             yaml_path: str = None,
 
             interface_class: str = None,  # including parameter definition excel
-            interface_kwargs: str = None,  # including Parametric Analysis Output
+            interface_kwargs: str | dict = None,  # including Parametric Analysis Output
             optimizer_class: str = None,
-            optimizer_kwargs: str = None,
-            femopt_kwargs: str = None,
+            optimizer_kwargs: str | dict = None,
             seed: str = 'null',
-            optimize_kwargs: str = None,
-            additional_module_paths: list[str] = None,
+            optimize_kwargs: str | dict = None,
+            additional_module_paths: str | list[str] = None,
 
             confirm_before_abnormal_termination: bool = True,
     ):
@@ -80,17 +74,16 @@ try:
                 and load by .yaml file.
                 The yaml file must contain the other arguments.
 
-            interface_class: FemtetWithExcelSettingsInterface or SurrogateModelInterface.
+            interface_class: Class whose name ends with `~WithExcelSettingsInterface`.
             interface_kwargs: See documentation of each interface class.
             optimizer_class: OptunaOptimizer or ScipyOptimizer.
             optimizer_kwargs: See documentation of each optimizer class.
-            femopt_kwargs: See documentation of FEMOpt.
             seed: int or None.
             optimize_kwargs: See documentation of FEMOpt.optimize().
             additional_module_paths:
                 The .py file paths containing user-defined objective and constraints functions.
                 The module must contain __objective_functions__ or __constraint_functions__.
-                They must be a dict variable that contains the required arguments of
+                They must be a `list` of `dict` that contains the required arguments of
                 `FEMOpt.add_objective()` or `FEMOpt.add_constraint()` method.
                 Note that the `args` argument of constraint function is reserved by meta_script
                 and that value is fixed to `FEMOpt.opt`, so you can not use `args` argument
@@ -104,37 +97,44 @@ try:
         global CONFIRM_BEFORE_ABNORMAL_TERMINATION
         CONFIRM_BEFORE_ABNORMAL_TERMINATION = confirm_before_abnormal_termination
 
-        # load variables from yaml file
+        # Override arguments,
+        # if yaml is given.
+        # ===================
         if yaml_path is not None:
 
             # check
             if os.path.isfile(yaml_path):
-                context = open(yaml_path, 'r', encoding='utf-8')
+                # noinspection PyBroadException
+                try:
+                    context = open(yaml_path, 'r', encoding='utf-8')
+                except Exception:
+                    context = open(yaml_path, 'r', encoding=ENCODING)
 
             else:
-                if DEBUG:
-                    print('debug mode')
-                    context = ContentContext(yaml_path)  # yaml_path is yaml content
-
-                else:
-                    raise FileNotFoundError(yaml_path)
+                raise FileNotFoundError(yaml_path)
 
-            # load **as yaml content**
+            # load
             with context as f:
                 d = yaml.safe_load(f)
                 interface_class = yaml.safe_dump(d['interface_class'], allow_unicode=True)
                 interface_kwargs = yaml.safe_dump(d['interface_kwargs'], allow_unicode=True)
                 optimizer_class = yaml.safe_dump(d['optimizer_class'], allow_unicode=True)
                 optimizer_kwargs = yaml.safe_dump(d['optimizer_kwargs'], allow_unicode=True)
-                femopt_kwargs = yaml.safe_dump(d['femopt_kwargs'], allow_unicode=True)
                 seed = yaml.safe_dump(d['seed'], allow_unicode=True)
                 optimize_kwargs = yaml.safe_dump(d['optimize_kwargs'], allow_unicode=True)
                 additional_module_paths = yaml.safe_dump(d.get('additional_module_paths', None), allow_unicode=True)
 
-        # load **python variables** from yaml content
+        # Construct python variables
+        # by evaluating string
+        # or Fire arguments
+        # ==========================
 
         # additional import
-        additional_module_paths_ = yaml.safe_load(additional_module_paths)
+        # -----------------
+        if yaml_path is not None:
+            additional_module_paths_ = yaml.safe_load(additional_module_paths)
+        else:
+            additional_module_paths_ = [yaml.safe_load(p) for p in additional_module_paths]
 
         if additional_module_paths_ is not None:
 
@@ -147,24 +147,43 @@ try:
                 if hasattr(additional_module, '__all__'):
                     globals().update({key: getattr(additional_module, key) for key in additional_module.__all__})
 
-        Interface = eval(yaml.safe_load(interface_class))
-        interface_kwargs_ = yaml.safe_load(interface_kwargs)
+        # Python variables
+        # ----------------
+        if yaml_path is not None:
+            Interface = eval(yaml.safe_load(interface_class))
+            interface_kwargs_ = yaml.safe_load(interface_kwargs)
+
+            Optimizer = eval(yaml.safe_load(optimizer_class))
+            optimizer_kwargs_ = yaml.safe_load(optimizer_kwargs)
 
-        Optimizer = eval(yaml.safe_load(optimizer_class))
-        optimizer_kwargs_ = yaml.safe_load(optimizer_kwargs)
+            optimizer_kwargs_['sampler_class'] = eval(optimizer_kwargs_['sampler_class'])
 
-        optimizer_kwargs_['sampler_class'] = eval(optimizer_kwargs_['sampler_class'])
+            seed_ = yaml.safe_load(seed)
 
-        femopt_kwargs_ = yaml.safe_load(femopt_kwargs)
+            optimize_kwargs_ = yaml.safe_load(optimize_kwargs)
 
-        seed_ = yaml.safe_load(seed)
+        else:
+            Interface = eval(interface_class)
+            interface_kwargs_ = interface_kwargs
 
-        optimize_kwargs_ = yaml.safe_load(optimize_kwargs)
+            Optimizer = eval(optimizer_class)
+            optimizer_kwargs_ = optimizer_kwargs
 
+            optimizer_kwargs_['sampler_class'] = eval(optimizer_kwargs_['sampler_class'])
+
+            seed_ = seed
+
+            optimize_kwargs_ = optimize_kwargs
+
+        # meta-script
+        # ===========
+
+        # prepare common object
         fem = Interface(**interface_kwargs_)
         opt = Optimizer(**optimizer_kwargs_)
-        femopt = FEMOpt(fem=fem, opt=opt, **femopt_kwargs_)
+        femopt = FEMOpt(fem=fem, opt=opt)
 
+        # add user-defined functions
         if additional_module_paths_ is not None:
 
             for i, path_ in enumerate(additional_module_paths_):
@@ -196,6 +215,7 @@ try:
                             kwargs=d.get('kwargs'),
                         )
 
+        # optimize
         femopt.set_random_seed(seed_)
         femopt.optimize(**optimize_kwargs_)
 
@@ -210,4 +230,6 @@ except Exception as e:
     print_exception(e)
     print()
     if CONFIRM_BEFORE_ABNORMAL_TERMINATION:
-        input('終了するには Enter を押してください。')
+        input('Press Enter to quit...')
+
+    raise e  # for test

pyfemtet/opt/optimizer/__init__.py

@@ -1,16 +1,14 @@
-from pyfemtet.opt.optimizer._base import AbstractOptimizer, logger, OptimizationMethodChecker
-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._base_optimizer import AbstractOptimizer, SubFidelityModel
+from pyfemtet.opt.optimizer.optuna_optimizer import OptunaOptimizer, PoFConfig, PoFBoTorchSampler, PartialOptimizeACQFConfig
+from pyfemtet.opt.optimizer.scipy_optimizer import ScipyOptimizer
 
-from pyfemtet.opt.optimizer._optuna._pof_botorch import PoFBoTorchSampler, PoFConfig
 
 __all__ = [
-    'ScipyScalarOptimizer',
-    'ScipyOptimizer',
-    'OptunaOptimizer',
     'AbstractOptimizer',
-    'logger',
+    'SubFidelityModel',
+    'OptunaOptimizer',
     'PoFBoTorchSampler',
     'PoFConfig',
+    'ScipyOptimizer',
+    'PartialOptimizeACQFConfig',
 ]