pyfemtet 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

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

@@ -326,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]
 
@@ -340,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,
@@ -356,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()
@@ -503,6 +508,17 @@ class ColumnManager:
                     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
@@ -578,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)
@@ -672,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)
@@ -689,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():
@@ -723,6 +744,9 @@ class Record:
         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()},
             columns=tuple(dtypes.keys())
@@ -917,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 に含まれないならば
@@ -958,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)
 
@@ -965,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,
         )
@@ -1139,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
@@ -1151,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
@@ -1189,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)
 
@@ -1201,6 +1238,7 @@ class History:
                 parameters,
                 self.obj_names,
                 self.cns_names,
+                self.other_output_names,
                 self.sub_fidelity_names,
                 self.additional_data,
             )
@@ -1210,6 +1248,7 @@ class History:
             parameters: TrialInput,
             obj_names,
             cns_names,
+            other_output_names,
             sub_fidelity_names,
             additional_data,
     ):
@@ -1218,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
@@ -1381,6 +1422,8 @@ class History:
         self._records.save(self.path)
 
     def _create_optuna_study_for_visualization(self):
+        """出力は internal ではない値で、objective は出力という意味であり cns, other_output を含む。"""
+
         import optuna
 
         # create study
@@ -1388,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
@@ -1441,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,32 @@ 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)
+                    record.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 +900,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/problem/problem.py

@@ -28,7 +28,9 @@ __all__ = [
     'TrialInput',
     'TrialOutput',
     'TrialConstraintOutput',
+    'TrialFunctionOutput',
     'Function',
+    'FunctionResult',
     'Functions',
     'Objective',
     'ObjectiveResult',
@@ -138,6 +140,12 @@ class Objective(Function):
         return self._convert(value, self.direction)
 
 
+class FunctionResult:
+
+    def __init__(self, func: Function, fem: AbstractFEMInterface):
+        self.value: float = func.eval(fem)
+
+
 class ObjectiveResult:
 
     def __init__(self, obj: Objective, fem: AbstractFEMInterface, obj_value: float = None):
@@ -302,3 +310,4 @@ SubSampling: TypeAlias = int
 TrialInput: TypeAlias = dict[str, Variable]
 TrialOutput: TypeAlias = dict[str, ObjectiveResult]
 TrialConstraintOutput: TypeAlias = dict[str, ConstraintResult]
+TrialFunctionOutput: TypeAlias = dict[str, FunctionResult]

pyfemtet/opt/problem/variable_manager/_variable_manager.py

@@ -304,7 +304,7 @@ class VariableManager:
             filter: (Literal['pass_to_fem', 'parameter']
                      | tuple[Literal['pass_to_fem', 'parameter']]
                      | None) = None,  # 'pass_to_fem' and 'parameter' (OR filter)
-            format: str = None,  # None, 'dict' and 'values'
+            format: Literal['dict', 'values', 'raw'] | None = None,  # Defaults to 'raw'
     ) -> (
         dict[str, Variable]
         | dict[str, Parameter]