pyfemtet 1.0.0a0__py3-none-any.whl → 1.0.1__py3-none-any.whl

pyfemtet/opt/optimizer/_base_optimizer.py

@@ -32,7 +32,7 @@ DIRECTION: TypeAlias = (
         ]
 )
 
-logger = get_module_logger('opt.optimizer', True)
+logger = get_module_logger('opt.optimizer', False)
 
 
 def _log_hidden_constraint(e: Exception):
@@ -177,11 +177,14 @@ class AbstractOptimizer:
             name: str,
             expression_string: str,
             properties: dict[str, ...] | None = None,
+            *,
+            pass_to_fem: bool = True,
     ) -> None:
         var = ExpressionFromString()
         var.name = name
         var._expr = ExpressionFromString.InternalClass(expression_string=expression_string)
         var.properties = properties or dict()
+        var.pass_to_fem = pass_to_fem
         _duplicated_name_check(name, self.variable_manager.variables.keys())
         self.variable_manager.variables.update({name: var})
 
@@ -190,11 +193,14 @@ class AbstractOptimizer:
             name: str,
             sympy_expr: sympy.Expr,
             properties: dict[str, ...] | None = None,
+            *,
+            pass_to_fem: bool = True,
     ) -> None:
         var = ExpressionFromString()
         var.name = name
         var._expr = ExpressionFromString.InternalClass(sympy_expr=sympy_expr)
         var.properties = properties or dict()
+        var.pass_to_fem = pass_to_fem
         _duplicated_name_check(name, self.variable_manager.variables.keys())
         self.variable_manager.variables.update({name: var})
 
@@ -205,6 +211,8 @@ class AbstractOptimizer:
             properties: dict[str, ...] | None = None,
             args: tuple | None = None,
             kwargs: dict | None = None,
+            *,
+            pass_to_fem: bool = True,
     ) -> None:
         var = ExpressionFromFunction()
         var.name = name
@@ -212,6 +220,7 @@ class AbstractOptimizer:
         var.args = args or tuple()
         var.kwargs = kwargs or dict()
         var.properties = properties or dict()
+        var.pass_to_fem = pass_to_fem
         _duplicated_name_check(name, self.variable_manager.variables.keys())
         self.variable_manager.variables.update({name: var})
 
@@ -425,6 +434,7 @@ class AbstractOptimizer:
 
         def __init__(self, opt: AbstractOptimizer):
             self.opt: AbstractOptimizer = opt
+            self.subsampling_idx: SubSampling | None = None
 
         def _preprocess(self):
             pass
@@ -451,6 +461,7 @@ class AbstractOptimizer:
                 variables_pass_to_fem: dict[str, SupportedVariableTypes],
                 history: History = None,
                 datetime_start=None,
+                trial_id=None,
         ) -> _FReturnValue:
 
             # create context
@@ -477,6 +488,8 @@ class AbstractOptimizer:
                     {obj_name: ObjectiveResult(obj, opt_.fem, float('nan'))
                      for obj_name, obj in opt_.objectives.items()}
                 )
+                record.sub_sampling = self.subsampling_idx
+                record.trial_id = trial_id
                 record.sub_fidelity_name = opt_.sub_fidelity_name
                 record.fidelity = opt_.fidelity
                 record.datetime_start = datetime_start
@@ -489,7 +502,8 @@ class AbstractOptimizer:
                     raise SkipSolve
 
                 # start solve
-                if opt_.sub_fidelity_models != MAIN_FIDELITY_NAME:
+                if opt_.sub_fidelity_name != MAIN_FIDELITY_NAME:
+                    logger.info('----------')
                     logger.info(_('fidelity: ({name})', name=opt_.sub_fidelity_name))
                 logger.info(_('input variables:'))
                 logger.info(parameters)
@@ -620,7 +634,9 @@ class AbstractOptimizer:
                 x: TrialInput,
                 x_pass_to_fem_: dict[str, SupportedVariableTypes],
                 opt_: AbstractOptimizer | None = None,
+                trial_id: str =None,
         ) -> _FReturnValue | None:
+            """Nothing will be raised even if infeasible."""
 
             vm = self.opt.variable_manager
 
@@ -634,32 +650,40 @@ class AbstractOptimizer:
             # if opt_ is not self, update variable manager
             opt_.variable_manager = vm
 
-            # preprocess
-            self._preprocess()
+            # noinspection PyMethodParameters
+            class Process:
+                def __enter__(self_):
+                    # preprocess
+                    self._preprocess()
 
-            # declare output
-            f_return = None
+                def __exit__(self_, exc_type, exc_val, exc_tb):
+                    # postprocess
+                    self._postprocess()
 
-            # start solve
-            datetime_start = datetime.datetime.now()
-            try:
-                f_return = self._solve_or_raise(
-                    opt_, x, x_pass_to_fem_, self.opt.history, datetime_start
-                )
+            with Process():
 
-            except HardConstraintViolation as e:
-                self._hard_constraint_handling(e)
+                # declare output
+                f_return = None
 
-            except _HiddenConstraintViolation as e:
-                self._hidden_constraint_handling(e)
+                # start solve
+                datetime_start = datetime.datetime.now()
+                try:
+                    f_return = self._solve_or_raise(
+                        opt_, x, x_pass_to_fem_, self.opt.history,
+                        datetime_start, trial_id
+                    )
 
-            except SkipSolve as e:
-                self._skip_handling(e)
+                except HardConstraintViolation as e:
+                    self._hard_constraint_handling(e)
 
-            else:
-                self._if_succeeded(f_return)
+                except _HiddenConstraintViolation as e:
+                    self._hidden_constraint_handling(e)
 
-            self._postprocess()
+                except SkipSolve as e:
+                    self._skip_handling(e)
+
+                else:
+                    self._if_succeeded(f_return)
 
             # check interruption
             self.opt._check_and_raise_interruption()
@@ -790,8 +814,19 @@ class AbstractOptimizer:
         # noinspection PyMethodParameters
         class LoggingOutput:
             def __enter__(self_):
-                self_.count = len(self.history.get_df()) + 1
-                logger.info(f'▼▼▼▼▼ solve {self_.count} start ▼▼▼▼▼')
+                df = self.history.get_df(
+                    equality_filters=MAIN_FILTER
+                )
+                self_.count = len(df) + 1
+
+                succeeded_count = len(df[df['state'] == TrialState.succeeded])
+                succeeded_text = _(
+                    en_message='{succeeded_count} succeeded trials',
+                    jp_message='成功した試行数: {succeeded_count}',
+                    succeeded_count=succeeded_count,
+                )
+
+                logger.info(f'▼▼▼▼▼ solve {self_.count} ({succeeded_text}) start ▼▼▼▼▼')
 
             def __exit__(self_, exc_type, exc_val, exc_tb):
                 logger.info(f'▲▲▲▲▲ solve {self_.count} end ▲▲▲▲▲\n')

pyfemtet/opt/optimizer/optuna_optimizer/_optuna_attribute.py

@@ -1,73 +1,63 @@
 from __future__ import annotations
 
+from typing import TypedDict, Sequence
+
+import optuna.trial
+
 from pyfemtet.opt.problem.problem import *
 from pyfemtet.opt.history import *
 from pyfemtet.opt.optimizer._base_optimizer import *
 
 
 class OptunaAttribute:
-    """Manage optuna user attribute
+    """Manage optuna user attribute.
 
-    user attributes are:
-        sub_fidelity_name:
+    By `set_user_attr_to_trial`,
+        key (str):
+            {sub_fidelity_name}(_{subsampling_idx})
+        value (dict):
             fidelity: ...
-            OBJECTIVE_ATTR_KEY: ...
-            PYFEMTET_STATE_ATTR_KEY: ...
-            CONSTRAINT_ATTR_KEY: ...
+            internal_y_values: ...
+            violation_values: ...
+            pf_state: ...
 
     """
-
-    OBJECTIVE_KEY = 'internal_objective'
-    CONSTRAINT_KEY = 'constraint'
-    PYFEMTET_TRIAL_STATE_KEY = 'pyfemtet_trial_state'
-
-    sub_fidelity_name: str  # key
-    fidelity: Fidelity | None
-    v_values: tuple | None  # violation
-    y_values: tuple | None  # internal objective
-    pf_state: TrialState | None  # PyFemtet state
-
-    def __init__(self, opt: AbstractOptimizer):
-        self.sub_fidelity_name = opt.sub_fidelity_name
-        self.fidelity = None
-        self.v_values = None
-        self.y_values = None
-        self.pf_state = None
-
-    # noinspection PyPropertyDefinition
-    @classmethod
-    def main_fidelity_key(cls):
-        return MAIN_FIDELITY_NAME
+    class AttributeStructure(TypedDict):
+        fidelity: Fidelity | None
+        internal_y_values: Sequence[float] | None
+        violation_values: Sequence[float] | None
+        pf_state: TrialState | None
+
+    def __init__(
+            self,
+            opt: AbstractOptimizer,
+            subsampling_idx: SubSampling | None = None,
+    ):
+        # key
+        self.sub_fidelity_name: str = opt.sub_fidelity_name
+        self.subsampling_idx: SubSampling | None = subsampling_idx
+        # value
+        self.fidelity: Fidelity = opt.fidelity
+        self.y_values: Sequence[float] | None = None
+        self.v_values: Sequence[float] | None = None
+        self.pf_state: TrialState | None = None
 
     @property
-    def key(self):
-        return self.sub_fidelity_name
+    def key(self) -> str:
+        key = self.sub_fidelity_name
+        if self.subsampling_idx is not None:
+            key += f'_{self.subsampling_idx}'
+        return key
 
     @property
-    def value(self):
-        d = {}
-        if self.fidelity:
-            d.update({'fidelity': self.fidelity})
-        if self.y_values:
-            d.update({self.OBJECTIVE_KEY: self.y_values})
-        if self.v_values:
-            d.update({self.CONSTRAINT_KEY: self.v_values})
-        if self.pf_state:
-            d.update({self.PYFEMTET_TRIAL_STATE_KEY: self.pf_state})
-        return d
-
-    @staticmethod
-    def get_fidelity(optuna_attribute: OptunaAttribute):
-        return optuna_attribute.value['fidelity']
-
-    @staticmethod
-    def get_violation(optuna_attribute: OptunaAttribute):
-        return optuna_attribute.value[OptunaAttribute.CONSTRAINT_KEY]
-
-    @staticmethod
-    def get_violation_from_trial_attr(trial_attr: dict):  # value is OptunaAttribute.value
-        return trial_attr[OptunaAttribute.CONSTRAINT_KEY]
-
-    @staticmethod
-    def get_pf_state_from_trial_attr(trial_attr: dict):  # value is OptunaAttribute.value
-        return trial_attr[OptunaAttribute.PYFEMTET_TRIAL_STATE_KEY]
+    def value(self) -> AttributeStructure:
+        out = self.AttributeStructure(
+            fidelity=self.fidelity,
+            internal_y_values=self.y_values,
+            violation_values=self.v_values,
+            pf_state=self.pf_state,
+        )
+        return out
+
+    def set_user_attr_to_trial(self, trial: optuna.trial.Trial):
+        trial.set_user_attr(self.key, self.value)

pyfemtet/opt/optimizer/optuna_optimizer/_optuna_optimizer.py

@@ -39,6 +39,37 @@ warnings.filterwarnings('ignore', 'Argument ``constraints_func`` is an experimen
 
 
 class OptunaOptimizer(AbstractOptimizer):
+    """
+    An optimizer class utilizing Optuna for hyperparameter optimization.
+
+    This class provides an interface to conduct optimization studies using Optuna.
+    It manages the study lifecycle, sampler configuration, and trial execution.
+
+    Attributes:
+        study_name (str): Name of the Optuna study.
+        storage (str | optuna.storages.BaseStorage): Storage URL or object for the Optuna study.
+        storage_path (str): Path to the Optuna study storage.
+        current_trial (optuna.trial.Trial | None): The current Optuna trial being evaluated.
+        sampler_class (type[optuna.samplers.BaseSampler]): The class of the Optuna sampler to use.
+        sampler_kwargs (dict): Keyword arguments to initialize the sampler.
+        n_trials (int | None): Number of trials to run in the study.
+        timeout (float | None): Maximum time allowed for the optimization.
+        callbacks (list): List of callback functions to invoke during optimization.
+
+    Args:
+        sampler_class (type[optuna.samplers.BaseSampler], optional): The sampler class for suggesting parameter values. Defaults to TPESampler if None.
+        sampler_kwargs (dict[str, ...], optional): Dictionary of keyword arguments for the sampler. Defaults to an empty dictionary.
+
+    Raises:
+        None
+
+    Examples:
+        >>> optimizer = OptunaOptimizer()
+        >>> optimizer.n_trials = 100
+        >>> optimizer.timeout = 600
+        >>> # Further configuration and usage...
+    """
+
     # system
     study_name = 'pyfemtet-study'
     storage: str | optuna.storages.BaseStorage
@@ -122,7 +153,7 @@ class OptunaOptimizer(AbstractOptimizer):
 
             y, dict_y_internal, c, record = f_return
 
-            # convert constraint to **sorted** violation
+            # convert constraint to **sorted 1-d array** violation
             assert len(c) == len(self.opt_.constraints)
             v = {}
             for cns_name, cns in self.opt_.constraints.items():
@@ -139,10 +170,7 @@ class OptunaOptimizer(AbstractOptimizer):
 
         def _postprocess(self):
             # update trial attribute
-            self.opt.current_trial.set_user_attr(
-                self.optuna_attr.key,
-                self.optuna_attr.value,
-            )
+            self.optuna_attr.set_user_attr_to_trial(self.opt.current_trial)
 
     def _create_infeasible_constraints(self, opt_: AbstractOptimizer = None) -> tuple:
         opt_ = opt_ if opt_ is not None else self
@@ -155,9 +183,9 @@ class OptunaOptimizer(AbstractOptimizer):
         return tuple(1e9 * np.ones(count, dtype=np.float64))
 
     def _constraint(self, trial: optuna.trial.FrozenTrial):
-        key = OptunaAttribute(self).key
-        value = trial.user_attrs[key]
-        return OptunaAttribute.get_violation_from_trial_attr(value)
+        main_key = OptunaAttribute(self).key
+        user_attribute: OptunaAttribute.AttributeStructure = trial.user_attrs[main_key]
+        return user_attribute['violation_values']
 
     def _objective(self, trial: optuna.trial.Trial):
 
@@ -226,9 +254,9 @@ class OptunaOptimizer(AbstractOptimizer):
 
             # To avoid trial FAILED with hard constraint
             # violation, check pf_state and raise TrialPruned.
-            key = OptunaAttribute(self).key
-            value = trial.user_attrs[key]
-            state = OptunaAttribute.get_pf_state_from_trial_attr(value)
+            main_key = OptunaAttribute(self).key
+            user_attribute: OptunaAttribute.AttributeStructure = trial.user_attrs[main_key]
+            state: TrialState = user_attribute['pf_state']
             if state in [
                 TrialState.hard_constraint_violation,
                 TrialState.model_error,
@@ -245,9 +273,6 @@ class OptunaOptimizer(AbstractOptimizer):
 
             return y_internal
 
-        if get_client() is None:
-            self.history.save()
-
     def _get_callback(self, n_trials: int):
 
         # restart である場合、追加 N 回と見做す
@@ -587,16 +612,16 @@ def debug_1():
     _opt.add_parameter('x1', 1, -1, 1, step=0.1)
     _opt.add_parameter('x2', 1, -1, 1, step=0.1)
     _opt.add_categorical_parameter('x3', 'a', choices=['a', 'b', 'c'])
-    _opt.add_constraint('cns', _cns, lower_bound=-0.9, args=(_fem, _opt))
-    _opt.add_objective('obj1', _parabola, args=(_fem, _opt))
-    # _opt.add_objective('obj2', _parabola2, args=(_fem, _opt))
+    # _opt.add_constraint('cns', _cns, lower_bound=-0.9, args=(_opt,))
+    _opt.add_objective('obj1', _parabola, args=(_opt,))
+    # _opt.add_objective('obj2', _parabola2, args=(_opt,))
 
     # # ===== sub-fidelity =====
     # __fem = NoFEM()
     # __opt = SubFidelityModel()
     # __opt.fem = __fem
-    # __opt.add_objective('obj1', _parabola, args=(__fem, __opt))
-    # __opt.add_objective('obj2', _parabola2, args=(__fem, __opt))
+    # __opt.add_objective('obj1', _parabola, args=(__opt,))
+    # # __opt.add_objective('obj2', _parabola2, args=(__opt,))
     #
     # _opt.add_sub_fidelity_model(name='low-fidelity', sub_fidelity_model=__opt, fidelity=0.5)
     #
@@ -622,6 +647,96 @@ def debug_1():
     _opt.history.save()
 
 
+def debug_1s():
+    # from pyfemtet.opt.optimizer.optuna_optimizer.pof_botorch.pof_botorch_sampler import
+    # sampler = PoFBoTorchSampler(
+    #     n_startup_trials=5,
+    #     seed=42,
+    #     constraints_func=self._constraint,
+    #     pof_config=PoFConfig(
+    #         # consider_pof=False,
+    #         # feasibility_cdf_threshold='mean',
+    #     ),
+    #     partial_optimize_acqf_kwargs=PartialOptimizeACQFConfig(
+    #         # gen_candidates='scipy',
+    #         timeout_sec=5.,
+    #         # method='SLSQP'  # 'COBYLA, COBYQA, SLSQP or trust-constr
+    #         tol=0.1,
+    #         # scipy_minimize_kwargs=dict(),
+    #     ),
+    # )
+    # from optuna_integration import BoTorchSampler
+    # sampler = BoTorchSampler(n_startup_trials=5)
+
+    os.chdir(os.path.dirname(__file__))
+
+    def _parabola(_fem: AbstractFEMInterface, _opt: AbstractOptimizer) -> float:
+        d = _opt.get_variables()
+        x1 = d['x1']
+        x2 = d['x2']
+        # if _cns(_fem, _opt) < 0:
+        #     raise PostProcessError
+        return x1 ** 2 + x2 ** 2
+
+    def _parabola2(_fem: AbstractFEMInterface, _opt: AbstractOptimizer) -> float:
+        x = _opt.get_variables('values')
+        return ((x - 0.1) ** 2).sum()
+
+    def _cns(_fem: AbstractFEMInterface, _opt: AbstractOptimizer) -> float:
+        x = _opt.get_variables('values')
+        return x[0]
+
+    _fem = NoFEM()
+    _opt = OptunaOptimizer()
+    _opt.fem = _fem
+
+    # _opt.sampler = optuna.samplers.RandomSampler(seed=42)
+    _opt.seed = 42
+    _opt.sampler_class = optuna.samplers.TPESampler
+    # _opt.sampler_class = optuna.samplers.RandomSampler
+    _opt.sampler_kwargs = dict(
+        n_startup_trials=5,
+    )
+    _opt.n_trials = 10
+
+    _opt.add_parameter('x1', 1, -1, 1, step=0.1)
+    _opt.add_parameter('x2', 1, -1, 1, step=0.1)
+    _opt.add_categorical_parameter('x3', 'a', choices=['a', 'b', 'c'])
+    # _opt.add_constraint('cns', _cns, lower_bound=-0.9, args=(_opt,))
+    _opt.add_objective('obj1', _parabola, args=(_opt,))
+    # _opt.add_objective('obj2', _parabola2, args=(_opt,))
+
+    # ===== sub-fidelity =====
+    __fem = NoFEM()
+    __opt = SubFidelityModel()
+    __opt.fem = __fem
+    __opt.add_objective('obj1', _parabola, args=(__opt,))
+    # __opt.add_objective('obj2', _parabola2, args=(__opt,))
+
+    _opt.add_sub_fidelity_model(name='low-fidelity', sub_fidelity_model=__opt, fidelity=0.5)
+
+    def _solve_condition(_history: History):
+
+        sub_fidelity_df = _history.get_df(
+            {'sub_fidelity_name': 'low-fidelity'}
+        )
+        idx = sub_fidelity_df['state'] == TrialState.succeeded
+        pdf = sub_fidelity_df[idx]
+
+        return len(pdf) % 5 == 0
+
+    _opt.set_solve_condition(_solve_condition)
+
+    # _opt.history.path = 'restart-test.csv'
+    _opt.run()
+
+    # import plotly.express as px
+    # _df = _opt.history.get_df()
+    # px.scatter_3d(_df, x='x1', y='x2', z='obj', color='fidelity', opacity=0.5).show()
+
+    _opt.history.save()
+
+
 def substrate_size(Femtet):
     """基板のXY平面上での専有面積を計算します。"""
     substrate_w = Femtet.GetVariableValue('substrate_w')
@@ -669,10 +784,13 @@ def debug_3():
     opt.add_parameter(name="substrate_d", initial_value=60, lower_bound=34, upper_bound=60)
 
     opt.n_trials = 5
-    opt.history.path = os.path.join(os.path.dirname(__file__), 'femtet-test.csv')
+    opt.history.path = os.path.join(os.path.dirname(__file__), 'femtet-test-2.csv')
 
     opt.run()
 
 
 if __name__ == '__main__':
+    debug_1()
+    debug_1s()
+    debug_2()
     debug_3()

pyfemtet/opt/optimizer/optuna_optimizer/_pof_botorch/pof_botorch_sampler.py

@@ -138,7 +138,7 @@ if TYPE_CHECKING:
 # noinspection PyTypeChecker
 _logger = get_logger(False)
 
-DEBUG = True
+DEBUG = False
 logger = get_module_logger('opt.PoFBoTorchSampler', DEBUG)
 
 warnings.filterwarnings('ignore', category=InputDataWarning)
@@ -973,9 +973,9 @@ class PoFBoTorchSampler(BoTorchSampler):
         feasible_trials: list[FrozenTrial] = []
         infeasible_trials: list[FrozenTrial] = []
         for trial in (completed_trials + pruned_trials):
-            state: PFTrialState = OptunaAttribute.get_pf_state_from_trial_attr(
-                trial.user_attrs[OptunaAttribute.main_fidelity_key()]
-            )
+            main_key = OptunaAttribute(self.pyfemtet_optimizer).key
+            user_attribute: OptunaAttribute.AttributeStructure = trial.user_attrs[main_key]
+            state: PFTrialState = user_attribute['pf_state']
 
             if state in self.pof_config._states_to_consider_pof:
                 infeasible_trials.append(trial)

pyfemtet/opt/optimizer/scipy_optimizer/_scipy_optimizer.py

@@ -36,6 +36,25 @@ class _ScipyCallback:
 
 
 class ScipyOptimizer(AbstractOptimizer):
+    """
+    Optimizer class that utilizes SciPy optimization methods.
+
+    This class serves as a wrapper around SciPy's optimization routines,
+    allowing customization of the optimization method, tolerance, and options.
+    It also provides mechanisms for handling constraints with enhancement and scaling.
+
+    Attributes:
+        method (str): The optimization method to use (e.g., 'BFGS', 'Nelder-Mead').
+        tol (float or None): Tolerance for termination.
+        options (dict): Additional options to pass to the SciPy optimizer.
+        constraint_enhancement (float): Small value added to enhance constraint handling.
+        constraint_scaling (float): Scaling factor applied to constraints.
+
+    Args:
+        method (str): The optimization method to use (e.g., 'BFGS', 'Nelder-Mead').
+        tol (float or None): Tolerance for termination.
+        
+    """
 
     _timeout: None = None
     _n_trials: None = None