pyfemtet 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

pyfemtet/_i18n/locales/ja/LC_MESSAGES/messages.po

@@ -976,11 +976,11 @@ msgstr "解析モデル互換性チェックで不明なエラーが発生しま
 
 #: pyfemtet/opt/visualization/plotter/pm_graph_creator.py:146
 msgid "Upper of pred. std-dev"
-msgstr "予測標準偏差の上限"
+msgstr "予測の標準偏差(+)"
 
 #: pyfemtet/opt/visualization/plotter/pm_graph_creator.py:150
 msgid "Lower of pred. std-dev"
-msgstr "予測標準偏差の小さい方"
+msgstr "予測の標準偏差(-)"
 
 #: pyfemtet/opt/visualization/plotter/pm_graph_creator.py:183
 msgid "Std-dev of pred."

pyfemtet/opt/femopt.py

@@ -157,6 +157,15 @@ class FEMOpt:
     ):
         self.opt.add_constraint(name, fun, lower_bound, upper_bound, args, kwargs, strict, using_fem)
 
+    def add_other_output(
+            self,
+            name: str,
+            fun: Callable[..., float],
+            args: tuple | None = None,
+            kwargs: dict | None = None,
+    ):
+        self.opt.add_other_output(name, fun, args, kwargs)
+
     def add_sub_fidelity_model(
             self,
             name: str,

pyfemtet/opt/history/_history.py

@@ -261,6 +261,14 @@ class DataFrameWrapper:
 class CorrespondingColumnNameRuler:
     """:meta private:"""
 
+    @staticmethod
+    def cns_lower_bound_name(cns_name):
+        return cns_name + '_lower_bound'
+
+    @staticmethod
+    def cns_upper_bound_name(cns_name):
+        return cns_name + '_upper_bound'
+
     @staticmethod
     def direction_name(obj_name):
         return obj_name + '_direction'
@@ -318,6 +326,7 @@ class ColumnManager:
     parameters: TrialInput
     y_names: list[str]
     c_names: list[str]
+    other_output_names: list[str]
     column_dtypes: dict[str, type]
     meta_columns: list[str]
 
@@ -332,12 +341,14 @@ class ColumnManager:
             parameters: TrialInput,
             y_names,
             c_names,
+            other_output_names,
             additional_data: dict,
             column_order_mode: str = ColumnOrderMode.per_category,
     ):
         self.parameters = parameters
         self.y_names = y_names
         self.c_names = c_names
+        self.other_output_names=other_output_names
         self.set_full_sorted_column_information(
             additional_data=additional_data,
             column_order_mode=column_order_mode,
@@ -348,12 +359,14 @@ class ColumnManager:
             extra_parameters: TrialInput = None,
             extra_y_names: list[str] = None,
             extra_c_names: list[str] = None,
+            extra_other_output_names: list[str] = None,
             additional_data: dict = None,
             column_order_mode: str = ColumnOrderMode.per_category,
     ):
         extra_parameters = extra_parameters or TrialInput()
         extra_y_names = extra_y_names or []
         extra_c_names = extra_c_names or []
+        extra_other_output_names = extra_other_output_names or []
 
         # column name になるので重複は許されない
         column_dtypes: dict = NoDuplicateDict()
@@ -453,7 +466,7 @@ class ColumnManager:
 
                     # later
                     target_cds.update({f(name): object})  # str | float
-                    target_mcs.append(f('obj'))
+                    target_mcs.append('obj.direction')
 
                 for name in extra_y_names:
                     # later
@@ -466,16 +479,46 @@ class ColumnManager:
 
             elif key == 'c':
 
+                f_lb = CorrespondingColumnNameRuler.cns_lower_bound_name
+                f_ub = CorrespondingColumnNameRuler.cns_upper_bound_name
+
                 for name in self.c_names:
                     # important
                     column_dtypes.update({name: float})
                     meta_columns.append('cns')
 
+                    # later
+                    target_cds.update({f_lb(name): float})
+                    target_mcs.append('cns.lower_bound')
+
+                    # later
+                    target_cds.update({f_ub(name): float})
+                    target_mcs.append('cns.upper_bound')
+
                 for name in extra_c_names:
                     # later
                     target_cds.update({name: float})
                     target_mcs.append('')
 
+                    # later
+                    target_cds.update({f_lb(name): float})
+                    target_mcs.append('')
+
+                    # later
+                    target_cds.update({f_ub(name): float})
+                    target_mcs.append('')
+
+            elif key == 'other_outputs':
+                for name in self.other_output_names:
+                    # important
+                    column_dtypes.update({name: float})
+                    meta_columns.append('other_output.value')
+
+                for name in extra_other_output_names:
+                    # later
+                    target_cds.update({name: float})
+                    target_mcs.append('')
+
             # additional_data を入れる
             elif key == self._get_additional_data_column():
                 # important
@@ -551,6 +594,9 @@ class ColumnManager:
     def get_cns_names(self) -> list[str]:
         return self.filter_columns('cns')
 
+    def get_other_output_names(self) -> list[str]:
+        return self.filter_columns('other_output')
+
     @staticmethod
     def _is_numerical_parameter(prm_name, columns):
         prm_lb_name = CorrespondingColumnNameRuler.prm_lower_bound_name(prm_name)
@@ -645,6 +691,7 @@ class Record:
     x: TrialInput = dataclasses.field(default_factory=TrialInput)
     y: TrialOutput = dataclasses.field(default_factory=TrialOutput)
     c: TrialConstraintOutput = dataclasses.field(default_factory=TrialConstraintOutput)
+    other_outputs: TrialFunctionOutput = dataclasses.field(default_factory=TrialFunctionOutput)
     state: TrialState = TrialState.undefined
     datetime_start: datetime.datetime = dataclasses.field(default_factory=datetime.datetime.now)
     datetime_end: datetime.datetime = dataclasses.field(default_factory=datetime.datetime.now)
@@ -662,6 +709,7 @@ class Record:
         x: TrialInput = d.pop('x')
         y: TrialOutput = d.pop('y')
         c: TrialConstraintOutput = d.pop('c')
+        other_outputs: TrialFunctionOutput = d.pop('other_outputs')
 
         # prm
         for prm_name, param in x.items():
@@ -682,10 +730,22 @@ class Record:
         # messages to str
         messages_str = _RECORD_MESSAGE_DELIMITER.join(d['messages'])
         d.update({'messages': messages_str})
-        
+
+        # obj
         d.update(**{k: v.value for k, v in y.items()})
-        d.update(**{f'{k}_direction': v.direction for k, v in y.items()})
+        d.update(**{f'{CorrespondingColumnNameRuler.direction_name(k)}': v.direction for k, v in y.items()})
+
+        # cns
         d.update(**{k: v.value for k, v in c.items()})
+        f_lb = CorrespondingColumnNameRuler.cns_lower_bound_name
+        d.update(**{f'{f_lb(k)}': v.lower_bound
+                    for k, v in c.items()})
+        f_ub = CorrespondingColumnNameRuler.cns_upper_bound_name
+        d.update(**{f'{f_ub(k)}': v.upper_bound
+                    for k, v in c.items()})
+
+        # function
+        d.update(**{k: v.value for k, v in other_outputs.items()})
 
         df = pd.DataFrame(
             {k: [v] for k, v in d.items()},
@@ -881,11 +941,13 @@ class Records:
         loaded_prm_names = set(self.column_manager._filter_prm_names(loaded_columns, loaded_meta_columns))
         loaded_obj_names = set(self.column_manager._filter_columns('obj', loaded_columns, loaded_meta_columns))
         loaded_cns_names = set(self.column_manager._filter_columns('cns', loaded_columns, loaded_meta_columns))
+        loaded_other_output_names = set(self.column_manager._filter_columns('other_output.value', loaded_columns, loaded_meta_columns))
 
         # loaded df に存在するが Record に存在しないカラムを Record に追加
         extra_parameters = {}
         extra_y_names = []
         extra_c_names = []
+        extra_oo_names = []
         for l_col, l_meta in zip(loaded_columns, loaded_meta_columns):
 
             # 現在の Record に含まれないならば
@@ -922,6 +984,10 @@ class Records:
                 elif l_col in loaded_cns_names:
                     extra_c_names.append(l_col)
 
+                # other_output_name ならば
+                elif l_col in loaded_other_output_names:
+                    extra_oo_names.append(l_col)
+
         # additional data を取得
         a_data = self.column_manager._get_additional_data(loaded_columns, loaded_meta_columns)
 
@@ -929,6 +995,7 @@ class Records:
             extra_parameters=extra_parameters,
             extra_y_names=extra_y_names,
             extra_c_names=extra_c_names,
+            extra_other_output_names=extra_oo_names,
             additional_data=a_data,
             column_order_mode=column_order_mode,
         )
@@ -1103,6 +1170,7 @@ class History:
     prm_names: list[str]
     obj_names: list[str]
     cns_names: list[str]
+    other_output_names: list[str]
     sub_fidelity_names: list[str]
     is_restart: bool
     additional_data: dict
@@ -1115,6 +1183,10 @@ class History:
     when the optimization process starts.
     """
 
+    @property
+    def all_output_names(self) -> list[str]:
+        return self.obj_names + self.cns_names + self.other_output_names
+
     def __init__(self):
         self._records = Records()
         self.path: str | None = None
@@ -1153,6 +1225,7 @@ class History:
             self.prm_names = ColumnManager._filter_prm_names(df.columns, meta_columns)
             self.obj_names = ColumnManager._filter_columns('obj', df.columns, meta_columns)
             self.cns_names = ColumnManager._filter_columns('cns', df.columns, meta_columns)
+            self.other_output_names = ColumnManager._filter_columns('other_output.value', df.columns, meta_columns)
             self.sub_fidelity_names = ColumnManager._get_sub_fidelity_names(df)
             self.additional_data = ColumnManager._get_additional_data(df.columns, meta_columns)
 
@@ -1165,6 +1238,7 @@ class History:
                 parameters,
                 self.obj_names,
                 self.cns_names,
+                self.other_output_names,
                 self.sub_fidelity_names,
                 self.additional_data,
             )
@@ -1174,6 +1248,7 @@ class History:
             parameters: TrialInput,
             obj_names,
             cns_names,
+            other_output_names,
             sub_fidelity_names,
             additional_data,
     ):
@@ -1182,13 +1257,15 @@ class History:
         self.prm_names = list(parameters.keys())
         self.obj_names = list(obj_names)
         self.cns_names = list(cns_names)
+        self.other_output_names = list(other_output_names)
         self.sub_fidelity_names = list(sub_fidelity_names)
         self.additional_data.update(additional_data)
 
         if not self._finalized:
             # ここで column_dtypes が決定する
             self._records.column_manager.initialize(
-                parameters, self.obj_names, self.cns_names, self.additional_data, self.column_order_mode
+                parameters, self.obj_names, self.cns_names, self.other_output_names,
+                self.additional_data, self.column_order_mode
             )
 
             # initialize
@@ -1320,7 +1397,7 @@ class History:
                 if row is not None:
                     self_.postprocess_after_recording(row)
 
-                # save history
+                # save history if no FEMOpt
                 client = get_client()
                 if client is None:
                     self.save()
@@ -1332,9 +1409,21 @@ class History:
 
         The destination path is :class:`History.path`.
         """
+
+        # flask server 情報のように、最適化の途中で
+        # 書き換えられるケースがあるので
+        # additional data を再度ここで meta_columns に反映する
+        cm = self._records.column_manager
+        for i, column in enumerate(cm.column_dtypes.keys()):
+            # additional_data を入れる
+            if column == cm._get_additional_data_column():
+                cm.meta_columns[i] = json.dumps(self.additional_data or dict())
+
         self._records.save(self.path)
 
     def _create_optuna_study_for_visualization(self):
+        """出力は internal ではない値で、objective は出力という意味であり cns, other_output を含む。"""
+
         import optuna
 
         # create study
@@ -1342,10 +1431,10 @@ class History:
             # storage='sqlite:///' + os.path.basename(self.path) + '_dummy.db',
             sampler=None, pruner=None, study_name='dummy',
         )
-        if len(self.obj_names) == 1:
+        if len(self.all_output_names) == 1:
             kwargs.update(dict(direction='minimize'))
         else:
-            kwargs.update(dict(directions=['minimize']*len(self.obj_names)))
+            kwargs.update(dict(directions=['minimize']*len(self.all_output_names)))
         study = optuna.create_study(**kwargs)
 
         # add trial to study
@@ -1395,11 +1484,19 @@ class History:
                 )
             trial_kwargs.update(dict(distributions=distributions))
 
-            # objective
-            if len(self.obj_names) == 1:
-                trial_kwargs.update(dict(value=row[self.obj_names].values[0]))
+            # objective (+ constraints + other_outputs as objective)
+            if len(self.all_output_names) == 1:
+                if len(self.obj_names) == 1:
+                    trial_kwargs.update(dict(value=row[self.obj_names].values[0]))
+                elif len(self.cns_names) == 1:
+                    trial_kwargs.update(dict(value=row[self.cns_names].values[0]))
+                elif len(self.other_output_names) == 1:
+                    trial_kwargs.update(dict(value=row[self.other_output_names].values[0]))
+                else:
+                    assert False
             else:
-                trial_kwargs.update(dict(values=row[self.obj_names].values))
+                values = row[self.all_output_names].values
+                trial_kwargs.update(dict(values=values))
 
             # add to study
             trial = optuna.create_trial(**trial_kwargs)

pyfemtet/opt/optimizer/_base_optimizer.py

@@ -99,6 +99,7 @@ class AbstractOptimizer:
         self.variable_manager = VariableManager()
         self.objectives = Objectives()
         self.constraints = Constraints()
+        self.other_outputs = Functions()
 
         # multi-fidelity
         self.fidelity = None
@@ -339,6 +340,21 @@ class AbstractOptimizer:
         _duplicated_name_check(name, self.constraints.keys())
         self.constraints.update({name: cns})
 
+    def add_other_output(
+            self,
+            name: str,
+            fun: Callable[..., float],
+            args: tuple | None = None,
+            kwargs: dict | None = None,
+    ):
+
+        other_func = Function()
+        other_func.fun = fun
+        other_func.args = args or ()
+        other_func.kwargs = kwargs or {}
+        _duplicated_name_check(name, self.other_outputs.keys())
+        self.other_outputs.update({name: other_func})
+
     def add_sub_fidelity_model(
             self,
             name: str,
@@ -352,12 +368,12 @@ class AbstractOptimizer:
         _duplicated_name_check(name, self.sub_fidelity_models.keys())
         self.sub_fidelity_models._update(name, sub_fidelity_model, fidelity)
 
-    def get_variables(self, format='dict'):
+    def get_variables(self, format: Literal['dict', 'values', 'raw'] = 'dict'):
         return self.variable_manager.get_variables(
             format=format,
         )
 
-    def get_parameter(self, format='dict'):
+    def get_parameter(self, format: Literal['dict', 'values', 'raw'] = 'dict'):
         return self.variable_manager.get_variables(
             format=format, filter='parameter'
         )
@@ -399,6 +415,12 @@ class AbstractOptimizer:
                 out.update({name: cns_result})
         return out
 
+    def _other_outputs(self, out: TrialFunctionOutput) -> TrialFunctionOutput:
+        for name, other_func in self.other_outputs.items():
+            other_func_result = FunctionResult(other_func, self.fem)
+            out.update({name: other_func_result})
+        return out
+
     def _get_hard_constraint_violation_names(self, hard_c: TrialConstraintOutput) -> list[str]:
         violation_names = []
         for name, result in hard_c.items():
@@ -573,6 +595,7 @@ class AbstractOptimizer:
 
                 try:
                     y: TrialOutput = opt_._y()
+                    record.y = y
                     opt_._check_and_raise_interruption()
 
                 # if intentional error (by user)
@@ -604,7 +627,6 @@ class AbstractOptimizer:
                     _c.update(soft_c)
                     _c.update(hard_c)
 
-                    record.y = y
                     record.c = _c
                     record.state = TrialState.get_corresponding_state_from_exception(e)
                     record.messages.append(
@@ -619,12 +641,31 @@ class AbstractOptimizer:
                 c.update(soft_c)
                 c.update(hard_c)
 
+                # ===== evaluate other functions =====
+                logger.info(_('evaluating other functions...'))
+
+                other_outputs = TrialFunctionOutput()
+                try:
+                    opt_._other_outputs(other_outputs)
+
+                # if intentional error (by user)
+                except _HiddenConstraintViolation as e:
+                    _log_hidden_constraint(e)
+
+                    record.other_outputs = other_outputs
+                    record.state = TrialState.get_corresponding_state_from_exception(e)
+                    record.messages.append(
+                            _('Hidden constraint violation during '
+                              'another output function evaluation: ')
+                            + create_err_msg_from_exception(e))
+
+                    raise e
+
                 # get values as minimize
                 y_internal: dict = opt_._convert_y(y)
 
                 logger.info(_('output:'))
                 logger.info(y)
-                record.y = y
                 record.c = c
                 record.state = TrialState.succeeded
 
@@ -858,10 +899,11 @@ class AbstractOptimizer:
                 filter='parameter', format='raw'
             )
             self.history.finalize(
-                parameters,
-                list(self.objectives.keys()),
-                list(self.constraints.keys()),
-                [self.sub_fidelity_name] + list(self.sub_fidelity_models.keys()),
+                parameters=parameters,
+                obj_names=list(self.objectives.keys()),
+                cns_names=list(self.constraints.keys()),
+                other_output_names=list(self.other_outputs.keys()),
+                sub_fidelity_names=[self.sub_fidelity_name] + list(self.sub_fidelity_models.keys()),
                 additional_data=self._collect_additional_data()
             )
 

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

@@ -113,7 +113,7 @@ class _ConvertedConstraint:
 
         """
 
-        x = X.detach().numpy()
+        x = X.detach().cpu().numpy()
         cns_value = _evaluate_pyfemtet_cns(
             self.cns,
             self.opt,
@@ -124,6 +124,8 @@ class _ConvertedConstraint:
             return Tensor([cns_value - self.cns.lower_bound - self.ce])
         elif self.ub_or_lb == 'ub':
             return Tensor([self.cns.upper_bound - cns_value - self.ce])
+        else:
+            assert False
 
 
 # list[pyfemtet.opt.Constraint] について、正規化された入力に対し、 feasible or not を返す関数
@@ -184,7 +186,7 @@ class NonlinearInequalityConstraints:
         for each_num_restarts in ic_batch:
             feasible_q_list = []
             for each_q in each_num_restarts:
-                x: np.ndarray = each_q.detach().numpy()  # normalized parameters
+                x: np.ndarray = each_q.detach().cpu().numpy()  # normalized parameters
                 if _is_feasible(self.constraints, self.opt, self.trans, x, self.ce, self.cs):
                     feasible_q_list.append(each_q)  # Keep only feasible rows
 

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

@@ -841,6 +841,7 @@ class PoFConfig:
         )
     feasibility_cdf_threshold: float | str = 0.5  # or 'sample_mean'
     feasibility_noise: float | str | None = None  # 'no' to fixed minimum noise
+    remove_hard_constraints_from_gp: bool = False  # if consider_explicit_hard_constraint is False, no effect.
 
 
 # TODO:
@@ -1079,6 +1080,8 @@ class PoFBoTorchSampler(BoTorchSampler):
         if n_trials < self._n_startup_trials:
             return {}
 
+        # ===== ここまで変更なし =====
+
         trans = _SearchSpaceTransform(search_space)
         n_objectives = len(study.directions)
         values: numpy.ndarray | torch.Tensor = numpy.empty(
@@ -1099,23 +1102,48 @@ class PoFBoTorchSampler(BoTorchSampler):
                     ):  # BoTorch always assumes maximization.
                         value *= -1
                     values[trial_idx, obj_idx] = value
+
                 if self._constraints_func is not None:
+
+                    # get constraints
                     constraints = study._storage.get_trial_system_attrs(trial._trial_id).get(
                         _CONSTRAINTS_KEY
                     )
+
+                    # Explicit hard constraints を optimize_acqf で扱うならば
+                    # GP にはそれを渡さない (option)
+                    if (
+                            constraints is not None
+                            and self.pof_config.consider_explicit_hard_constraint
+                            and self.pof_config.remove_hard_constraints_from_gp
+                    ):
+                        constraints = filter_soft_constraints_only(
+                            constraints, self.pyfemtet_optimizer
+                        )
+
                     if constraints is not None:
+
                         n_constraints = len(constraints)
 
-                        if con is None:
-                            con = numpy.full(
-                                (n_completed_trials, n_constraints), numpy.nan, dtype=numpy.float64
-                            )
-                        elif n_constraints != con.shape[1]:
-                            raise RuntimeError(
-                                f"Expected {con.shape[1]} constraints "
-                                f"but received {n_constraints}."
-                            )
-                        con[trial_idx] = constraints
+                        # remove_hard_constraints_from_gp で
+                        # constraints がなくなった場合、
+                        # そもそも今後ここに来る必要がない
+                        if n_constraints == 0:
+                            self._constraints_func = None
+
+                        else:
+
+                            if con is None:
+                                con = numpy.full(
+                                    (n_completed_trials, n_constraints), numpy.nan, dtype=numpy.float64
+                                )
+                            elif n_constraints != con.shape[1]:
+                                raise RuntimeError(
+                                    f"Expected {con.shape[1]} constraints "
+                                    f"but received {n_constraints}."
+                                )
+                            con[trial_idx] = constraints
+
             elif trial.state == TrialState.RUNNING:
                 if all(p in trial.params for p in search_space):
                     params[trial_idx] = trans.transform(trial.params)
@@ -1162,7 +1190,6 @@ class PoFBoTorchSampler(BoTorchSampler):
         else:
             running_params = None
 
-        # ===== ここまで変更なし =====
 
         # TODO: ミーゼスなどの場合にこれらのシード固定法も試す
         # if self._seed is not None:
@@ -1247,3 +1274,28 @@ class PoFBoTorchSampler(BoTorchSampler):
         # ===== ここまで変更なし =====
 
         return trans.untransform(candidates.cpu().numpy())
+
+
+def filter_soft_constraints_only(
+        constraints: tuple[float],
+        opt: AbstractOptimizer,
+) -> list[float]:
+    # constraints を取得
+    # lb, ub の存在に応じて hard, soft を展開
+    is_soft_list = []
+    for cns in opt.constraints.values():
+        if cns.lower_bound is not None:
+            is_soft_list.append(not cns.hard)
+        if cns.upper_bound is not None:
+            is_soft_list.append(not cns.hard)
+
+    # constraints と比べる
+    assert len(constraints) == len(is_soft_list)
+
+    # soft に該当する要素のみで組立て返す
+    ret = []
+    for is_soft, value in zip(is_soft_list, constraints):
+        if is_soft:
+            ret.append(value)
+
+    return ret