pyfemtet 0.8.8__py3-none-any.whl → 0.8.10__py3-none-any.whl

pyfemtet/opt/advanced_samples/restart/gal_ex13_parametric_restart_jp.py

@@ -0,0 +1,102 @@
+import os
+from time import sleep
+
+from optuna.samplers import RandomSampler, NSGAIISampler, GPSampler, BaseSampler
+
+from pyfemtet.opt import FEMOpt, FemtetInterface, OptunaOptimizer
+
+os.chdir(os.path.dirname(__file__))
+
+
+def get_res_freq(Femtet):
+    Galileo = Femtet.Gogh.Galileo
+    Galileo.Mode = 0
+    sleep(0.01)
+    return Galileo.GetFreq().Real
+
+
+def main(n_trials, sampler_class: type[BaseSampler], sampler_kwargs: dict):
+    """メイン関数
+
+    このサンプルは最適化を途中で中断して続きから行う場合で、
+    各リスタートで異なるアルゴリズムを使用して
+    最適化を再開する方法を示しています。
+
+    このメイン関数は n_trials と sampler_class を与えると
+    その回数、アルゴリズムに応じて最適化を行います。
+
+    Args:
+
+        n_trials (int):
+            最適化を終了するために必要な追加の成功した試行回数。
+
+        sampler_class (type[optuna.samplers.BaseSampler]):
+            使用するアルゴリズム。
+        
+        sampler_kwargs (dict):
+            アルゴリズムの引数。
+
+    """
+
+
+    # Femtet に接続します。
+    fem = FemtetInterface(
+        femprj_path='gal_ex13_parametric.femprj',
+    )
+
+    # 最適化オブジェクトを初期化します。
+    opt = OptunaOptimizer(
+        sampler_class=sampler_class,
+        sampler_kwargs=sampler_kwargs,
+    )
+
+    # リスタートするためには以前の最適化の履歴を
+    # 新しい最適化プログラムに知らせる必要があります。
+    # FEMOpt の `history_path` 引数に csv を指定すると、
+    # それが存在しない場合、新しい csv ファイルを作り、
+    # それが存在する場合、その csv ファイルの続きから
+    # 最適化を実行します。
+    #
+    # 注意:
+    #   リスタートする場合、変数の数と名前、目的関数の数と
+    #   名前、および拘束関数の数と名前が一貫している必要が
+    #   あります。
+    #   ただし、変数の上下限や目的関数の方向、拘束関数の内容
+    #   などは変更できます。
+    #
+    # 注意:
+    #   OptunaOptimizer を使用する場合、csv と同名の
+    #   .db ファイル (ここでは restarting-sample.db) が
+    #   csv ファイルと同じフォルダにある必要があります。
+    femopt = FEMOpt(
+        fem=fem,
+        opt=opt,
+        history_path='restarting-sample.csv'
+    )
+
+    # 設計パラメータを指定します。
+    femopt.add_parameter('length', 0.1, 0.02, 0.2)
+    femopt.add_parameter('width', 0.01, 0.001, 0.02)
+    femopt.add_parameter('base_radius', 0.008, 0.006, 0.01)
+
+    # 目的関数を指定します。
+    femopt.add_objective(fun=get_res_freq, name='First Resonant Frequency (Hz)', direction=800)
+
+    # 最適化を実行します。
+    femopt.set_random_seed(42)
+    femopt.optimize(n_trials=n_trials, confirm_before_exit=False)
+
+
+if __name__ == '__main__':
+    # 最初に、RandomSampler を使用して 3 回計算を行います。
+    main(3, RandomSampler, {})
+
+    # 次に、NSGAIISampler を使用して 3 回計算を行います。
+    main(3, NSGAIISampler, {})
+
+    #  最後に、GPSampler を使用して 3 回計算を行います。
+    main(3, GPSampler, {'n_startup_trials': 0, 'deterministic_objective': True})
+
+    # このプログラム終了後、
+    # restarting-sample.csv と同名の .db ファイルを用いて
+    # さらに続きの最適化を行うことができます。

pyfemtet/opt/interface/__init__.py

@@ -25,7 +25,7 @@ from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
 from pyfemtet.opt.interface._surrogate._singletaskgp import PoFBoTorchInterface
 
 
-__all__ =[
+__all__ = [
     'FEMInterface',
     'NoFEM',
     'FemtetInterface',

pyfemtet/opt/interface/_base.py

@@ -24,18 +24,27 @@ class FEMInterface(ABC):
 
     """
 
+    kwargs = None
+
     def __init__(
             self,
             **kwargs
     ):
         # restore のための情報保管
-        self.kwargs = kwargs
+        if self.kwargs is None:
+            self.kwargs = kwargs
+        else:
+            self.kwargs.update(kwargs)
 
     @abstractmethod
     def update(self, parameters: pd.DataFrame) -> None:
         """Updates the FEM analysis based on the proposed parameters."""
         raise NotImplementedError('update() must be implemented.')
 
+    @property
+    def object_passed_to_functions(self):
+        return self
+
     def check_param_value(self, param_name) -> float or None:
         """Checks the value of a parameter in the FEM model (if implemented in concrete class)."""
         pass
@@ -50,13 +59,13 @@ class FEMInterface(ABC):
         pass
 
     def load_parameter(self, opt) -> None:  # opt: AbstractOptimizer
-        raise NotImplementedError()
+        pass
 
     def load_objective(self, opt) -> None:  # opt: AbstractOptimizer
-        raise NotImplementedError()
+        pass
 
     def load_constraint(self, opt) -> None:  # opt: AbstractOptimizer
-        raise NotImplementedError()
+        pass
 
     def _setup_before_parallel(self, client) -> None:
         """Preprocessing before launching a dask worker (if implemented in concrete class).

pyfemtet/opt/interface/_excel_interface.py

@@ -55,36 +55,36 @@ class ExcelInterface(FEMInterface):
         input_xlsm_path (str or Path):
             設計変数の定義を含む Excel ファイルのパスを指定
             します。
-            
+
         input_sheet_name (str):
             設計変数の定義を含むシートの名前を指定します。
-            
+
         output_xlsm_path (str or Path, optional):
             目的関数の定義を含む Excel ファイルのパスを指定
             します。指定しない場合は ``input_xlsm_path`` と
             同じと見做します。
-            
+
         output_sheet_name (str, optional):
             目的関数の定義を含む含むシートの名前を指定します。
             指定しない場合は ``input_sheet_name`` と同じと見
             做します。
-            
+
         procedure_name (str, optional):
             Excel マクロ関数名を指定します。指定しない場合は
             ``FemtetMacro.FemtetMain`` と見做します。
-            
+
         procedure_args (list or tuple, optional):
             Excel マクロ関数に渡す引数をリストまたはタプルで
             指定します。
-            
+
         connect_method (str, optional):
             Excel との接続方法を指定します。 'auto' または
             'new' が利用可能です。デフォルトは 'auto' です。
-            
+
         procedure_timeout (float or None, optional):
             Excel マクロ関数のタイムアウト時間を秒単位で指定
             します。 None の場合はタイムアウトなしとなります。
-            
+
         setup_xlsm_path (str or Path, optional):
             セットアップ時に呼ぶ関数を含む xlsm のパスです。
             指定しない場合は ``input_xlsm_path`` と
@@ -135,7 +135,7 @@ class ExcelInterface(FEMInterface):
     Attributes:
         input_xlsm_path (Path):
             設計変数の定義を含む Excel ファイルのパス。
-            
+
         input_sheet_name (str):
             設計変数の定義を含むシートの名前。
 
@@ -257,7 +257,7 @@ class ExcelInterface(FEMInterface):
         self.output_sheet_name = output_sheet_name if output_sheet_name is not None else input_sheet_name
         self.constraint_xlsm_path = str(input_xlsm_path) if constraint_xlsm_path is None else str(constraint_xlsm_path)
         self.constraint_sheet_name = constraint_sheet_name or self.input_sheet_name
-        self.procedure_name = procedure_name or 'FemtetMacro.FemtetMain'
+        self.procedure_name = procedure_name
         self.procedure_args = procedure_args or []
         assert connect_method in ['new', 'auto']
         self.connect_method = connect_method
@@ -271,7 +271,8 @@ class ExcelInterface(FEMInterface):
         self.setup_procedure_name = setup_procedure_name
         self.setup_procedure_args = setup_procedure_args or []
 
-        self.teardown_xlsm_path = str(input_xlsm_path) if teardown_xlsm_path is None else str(teardown_xlsm_path)  # あとで取得する
+        self.teardown_xlsm_path = str(input_xlsm_path) if teardown_xlsm_path is None else str(
+            teardown_xlsm_path)  # あとで取得する
         self.teardown_procedure_name = teardown_procedure_name
         self.teardown_procedure_args = teardown_procedure_args or []
 
@@ -516,7 +517,8 @@ class ExcelInterface(FEMInterface):
                 self.sh_constraint = sh
                 break
         else:
-            raise RuntimeError(f'Sheet {self.constraint_sheet_name} does not exist in the book {self.wb_constraint.Name}.')
+            raise RuntimeError(
+                f'Sheet {self.constraint_sheet_name} does not exist in the book {self.wb_constraint.Name}.')
 
         # ===== setup =====
         # 開く (setup)
@@ -618,18 +620,19 @@ class ExcelInterface(FEMInterface):
         self.update_parameter(parameters)
 
         # マクロ実行
-        try:
-            with watch_excel_macro_error(self.excel, timeout=self.procedure_timeout):
-                self.excel.Run(
-                    f'{self.procedure_name}',
-                    *self.procedure_args
-                )
+        if self.procedure_name is not None:
+            try:
+                with watch_excel_macro_error(self.excel, timeout=self.procedure_timeout):
+                    self.excel.Run(
+                        f'{self.procedure_name}',
+                        *self.procedure_args
+                    )
 
-            # 再計算
-            self.excel.CalculateFull()
+                # 再計算
+                self.excel.CalculateFull()
 
-        except com_error as e:
-            raise SolveError(f'Failed to run macro {self.procedure_name}. The original message is: {e}')
+            except com_error as e:
+                raise SolveError(f'Failed to run macro {self.procedure_name}. The original message is: {e}')
 
     def quit(self):
         if self.terminate_excel_when_quit:
@@ -655,7 +658,8 @@ class ExcelInterface(FEMInterface):
                         self.excel.CalculateFull()
 
                     except com_error as e:
-                        raise RuntimeError(f'Failed to run macro {self.teardown_procedure_args}. The original message is: {e}')
+                        raise RuntimeError(
+                            f'Failed to run macro {self.teardown_procedure_args}. The original message is: {e}')
 
             # 不具合の原因になる場合があるので参照設定は解除しないこと
             # self.remove_femtet_ref_xla(self.wb_input)
@@ -791,11 +795,14 @@ class ExcelInterface(FEMInterface):
                 opt.variables.add_expression(fixed_prm)
 
     def load_objective(self, opt):
-        from pyfemtet.opt.optimizer import AbstractOptimizer, logger
+        from pyfemtet.opt.optimizer import AbstractOptimizer
         from pyfemtet.opt._femopt_core import Objective
         opt: AbstractOptimizer
 
-        df = ParseAsObjective.parse(self.output_xlsm_path, self.output_sheet_name)
+        df = ParseAsObjective.parse(
+            self.output_xlsm_path,
+            self.output_sheet_name,
+        )
 
         for i, row in df.iterrows():
 
@@ -827,22 +834,19 @@ class ExcelInterface(FEMInterface):
                     kwargs=dict(),
                 )
 
-    def load_constraint(self, opt):
-        from pyfemtet.opt.optimizer import AbstractOptimizer, logger
+    def load_constraint(self, opt, raise_if_no_keyword=False):
+        from pyfemtet.opt.optimizer import AbstractOptimizer
         from pyfemtet.opt._femopt_core import Constraint
         opt: AbstractOptimizer
 
-        # TODO:
-        #   constraint は optional である。
-        #   現在は実装していないが、シートから問題を取得するよりよいロジックができたら
-        #   （つまり、同じシートからパラメータと拘束を取得出来るようになったら）__init__ 内で
-        #   constraint に None が与えられたのか故意に input_sheet_name と同じシート名を
-        #   与えられたのか分別できる実装に変えてそのチェック処理をここに反映する。
-        # constraint_sheet_name が指定されていない場合何もしない
-        if (self.constraint_sheet_name == self.input_sheet_name) and is_same_path(self.input_xlsm_path, self.constraint_xlsm_path):
-            return
-
-        df = ParseAsConstraint.parse(self.constraint_xlsm_path, self.constraint_sheet_name)
+        # constraint は optional であるが
+        # __init__ で input_sheet_name を入れられるので
+        # ここで constraint が実際に与えられているか判断する
+        df = ParseAsConstraint.parse(
+            self.constraint_xlsm_path,
+            self.constraint_sheet_name,
+            raise_if_no_keyword=raise_if_no_keyword,
+        )
 
         for i, row in df.iterrows():
 
@@ -877,7 +881,8 @@ class ExcelInterface(FEMInterface):
             calc_before_solve = True
             if ParseAsConstraint.calc_before_solve in df.columns:
                 _calc_before_solve = row[ParseAsConstraint.calc_before_solve]
-                calc_before_solve = True if is_cell_value_empty(_calc_before_solve) else bool(_calc_before_solve)  # bool or NaN
+                calc_before_solve = True if is_cell_value_empty(_calc_before_solve) else bool(
+                    _calc_before_solve)  # bool or NaN
 
             if use:
                 # constraint を作る
@@ -892,6 +897,7 @@ class ExcelInterface(FEMInterface):
                     using_fem=not calc_before_solve,
                 )
 
+    # TODO: femopt_core.Function の仕様を変えたらここも変える
     def objective_from_excel(self, name: str):
         r = 1 + search_r(self.output_xlsm_path, self.output_sheet_name, name)
         c = 1 + search_c(self.output_xlsm_path, self.output_sheet_name, ParseAsObjective.value)

pyfemtet/opt/interface/_femtet.py

@@ -192,7 +192,8 @@ class FemtetInterface(FEMInterface):
         # subprocess で restore するための情報保管
         # パスなどは connect_and_open_femtet での処理結果を反映し
         # メインで開いた解析モデルが確実に開かれるようにする
-        super().__init__(
+        FEMInterface.__init__(
+            self,
             femprj_path=self.femprj_path,
             model_name=self.model_name,
             open_result_with_gui=self.open_result_with_gui,
@@ -201,6 +202,43 @@ class FemtetInterface(FEMInterface):
             **kwargs
         )
 
+    @property
+    def object_passed_to_functions(self):
+        return self.Femtet
+
+    def use_parametric_output_as_objective(self, number: int, direction: str | float = 'minimize') -> None:
+        """Use output setting of Femtet parametric analysis as an objective function.
+
+        Args:
+            number (int): The index of output settings tab in parametric analysis dialog of Femtet. Starts at 1.
+            direction (str | float): Objective direction. Valid input is one of 'minimize', 'maximize' or a specific value. Defaults to 'minimize'.
+
+        Returns:
+            None
+
+        """
+        # check
+        if isinstance(direction, str):
+            if direction not in ('minimize', 'maximize'):
+                raise ValueError(f'direction must be one of "minimize", "maximize" or a specific value. Passed value is {direction}')
+        else:
+            try:
+                direction = float(direction)
+            except (TypeError, ValueError):
+                raise ValueError(f'direction must be one of "minimize", "maximize" or a specific value. Passed value is {direction}')
+
+        index = {number - 1: direction}
+
+        if self.parametric_output_indexes_use_as_objective is None:
+            self.parametric_output_indexes_use_as_objective = index
+
+        else:
+            self.parametric_output_indexes_use_as_objective.update(index)
+
+        # TODO: FEMInterface.__init__ の仕様を変えたらここも変える
+        self.kwargs['parametric_output_indexes_use_as_objective'] = self.parametric_output_indexes_use_as_objective
+
+
     def __del__(self):
         self.quit()
         # CoUninitialize()  # Win32 exception occurred releasing IUnknown at 0x0000022427692748
@@ -682,6 +720,14 @@ class FemtetInterface(FEMInterface):
 
         if self.parametric_output_indexes_use_as_objective is not None:
             from pyfemtet.opt.interface._femtet_parametric import solve_via_parametric_dll
+
+            pdt_path = self.Femtet.ResultFilePath + '.pdt'
+
+            # 前のものが残っているとややこしいので消しておく
+            if os.path.exists(pdt_path):
+                os.remove(pdt_path)
+
+            # parametric analysis 経由で解析
             self._call_femtet_api(
                 fun=solve_via_parametric_dll,
                 return_value_if_failed=False,
@@ -690,8 +736,23 @@ class FemtetInterface(FEMInterface):
                 is_Gaudi_method=True,
                 args=(self.Femtet,),
             )
+
+            # parametric analysis の場合
+            # ダイアログで「解析結果を保存する」に
+            # チェックがついていないと次にすべき
+            # OpenCurrentResult に失敗するので
+            # parametric の場合も pdt を保存する
+            self._call_femtet_api(
+                fun=self.Femtet.SavePDT,
+                args=(pdt_path, True),
+                return_value_if_failed=False,
+                if_error=SolveError,
+                error_message=Msg.ERR_FAILED_TO_SAVE_PDT,
+                is_Gaudi_method=False,
+            )
+
         else:
-            # # ソルブする
+            # ソルブする
             self._call_femtet_api(
                 self.Femtet.Solve,
                 False,

pyfemtet/opt/interface/_femtet_excel.py

@@ -0,0 +1,138 @@
+import re
+from pathlib import Path
+
+from pyfemtet.opt.interface._base import FEMInterface
+from pyfemtet.opt.interface._femtet import FemtetInterface
+from pyfemtet.opt.interface._excel_interface import (
+    ExcelInterface, is_cell_value_empty, ParseAsObjective, ScapeGoatObjective,
+    ParseAsConstraint, search_c, search_r
+)
+
+
+PARAMETRIC_PREFIX = 'パラメトリック'
+
+
+def get_number(name):
+    numbers = re.findall(r'\d+', name)
+    if len(numbers) == 0:
+        raise ValueError('パラメトリック結果出力の番号指定が検出できませんでした。')
+    else:
+        return int(numbers[0])
+
+
+
+class FemtetWithExcelSettingsInterface(FemtetInterface, ExcelInterface, FEMInterface):
+
+    def __init__(
+            self,
+
+            # FemtetInterface arguments
+            femprj_path: str = None, model_name: str = None, connect_method: str = 'auto',
+            save_pdt: str = 'all', strictly_pid_specify: bool = True, allow_without_project: bool = False,
+            open_result_with_gui: bool = True,
+            parametric_output_indexes_use_as_objective: dict[int, str or float] = None,
+
+            # ExcelInterface arguments
+            input_xlsm_path: str or Path = None, input_sheet_name: str = None, output_xlsm_path: str or Path = None,
+            output_sheet_name: str = None, constraint_xlsm_path: str or Path = None,
+            constraint_sheet_name: str = None, procedure_name: str = None, procedure_args: list or tuple = None,
+            procedure_timeout: float or None = None,
+            setup_xlsm_path: str or Path = None, setup_procedure_name: str = None,
+            setup_procedure_args: list or tuple = None, teardown_xlsm_path: str or Path = None,
+            teardown_procedure_name: str = None, teardown_procedure_args: list or tuple = None,
+            related_file_paths: list[str or Path] = None, visible: bool = False, display_alerts: bool = False,
+            terminate_excel_when_quit: bool = None, interactive: bool = True, use_named_range: bool = True,
+
+    ):
+        ExcelInterface.__init__(
+            self, input_xlsm_path, input_sheet_name, output_xlsm_path, output_sheet_name, constraint_xlsm_path,
+            constraint_sheet_name, procedure_name, procedure_args, connect_method, procedure_timeout,
+            setup_xlsm_path, setup_procedure_name, setup_procedure_args, teardown_xlsm_path,
+            teardown_procedure_name, teardown_procedure_args, related_file_paths, visible, display_alerts,
+            terminate_excel_when_quit, interactive, use_named_range)
+
+        FemtetInterface.__init__(
+            self,
+            femprj_path, model_name, connect_method, save_pdt, strictly_pid_specify, allow_without_project,
+            open_result_with_gui, parametric_output_indexes_use_as_objective
+        )
+
+
+    def load_objective(self, opt):
+        from pyfemtet.opt.optimizer import AbstractOptimizer
+        from pyfemtet.opt._femopt_core import Objective
+        opt: AbstractOptimizer
+
+        df = ParseAsObjective.parse(
+            self.output_xlsm_path,
+            self.output_sheet_name,
+            False
+        )
+
+        for i, row in df.iterrows():
+
+            # use(optional)
+            use = True
+            if ParseAsObjective.use in df.columns:
+                _use = row[ParseAsObjective.use]
+                use = False if is_cell_value_empty(_use) else bool(_use)  # bool or NaN
+
+            # name
+            name = str(row[ParseAsObjective.name])
+
+            # direction
+            direction = row[ParseAsObjective.direction]
+            assert not is_cell_value_empty(direction), 'direction is empty.'
+            try:
+                direction = float(direction)
+            except ValueError:
+                direction = str(direction).lower()
+                assert direction in ['minimize', 'maximize']
+
+            if use:
+
+                # name が「パラメトリック」から始まっていたら
+                # パラメトリック解析の結果を目的関数にする
+                if name.startswith(PARAMETRIC_PREFIX):
+                    number = get_number(name)
+                    self.use_parametric_output_as_objective(number, direction)
+
+                # そうでなければ通常の Excel objective を作る
+                else:
+                    opt.objectives[name] = Objective(
+                        fun=ScapeGoatObjective(),
+                        name=name,
+                        direction=direction,
+                        args=(name,),
+                        kwargs=dict(),
+                    )
+
+    def _setup_before_parallel(self, client):
+        FemtetInterface._setup_before_parallel(self, client)
+        ExcelInterface._setup_before_parallel(self, client)
+
+    def _setup_after_parallel(self, *args, **kwargs):
+        FemtetInterface._setup_after_parallel(self, *args, **kwargs)
+        ExcelInterface._setup_after_parallel(self, *args, **kwargs)
+
+    def update(self, parameters) -> None:
+        FemtetInterface.update(self, parameters)
+        ExcelInterface.update(self, parameters)
+
+    def quit(self, timeout=1, force=True):
+        FemtetInterface.quit(self, timeout, force)
+        ExcelInterface.quit(self)
+
+    # noinspection PyMethodOverriding
+    def objective_from_excel(self, _, name: str):
+        r = 1 + search_r(self.output_xlsm_path, self.output_sheet_name, name)
+        c = 1 + search_c(self.output_xlsm_path, self.output_sheet_name, ParseAsObjective.value)
+        v = self.sh_output.Cells(r, c).value
+        return float(v)
+
+    # noinspection PyMethodOverriding
+    def constraint_from_excel(self, _, name: str):
+        r = 1 + search_r(self.constraint_xlsm_path, self.constraint_sheet_name, name)
+        c = 1 + search_c(self.constraint_xlsm_path, self.constraint_sheet_name, ParseAsConstraint.value)
+        v = self.sh_constraint.Cells(r, c).value
+        return float(v)

pyfemtet/opt/interface/_surrogate/_base.py

@@ -17,6 +17,7 @@ class SurrogateModelInterfaceBase(FEMInterface, ABC):
             self,
             history_path: str = None,
             train_history: History = None,
+            _output_directions: dict[int, str | float] | list[str | float] = None,
     ):
 
         self.train_history: History
@@ -25,6 +26,7 @@ class SurrogateModelInterfaceBase(FEMInterface, ABC):
         self.obj: dict[str, float] = dict()
         self.df_prm: pd.DataFrame
         self.df_obj: pd.DataFrame
+        self._output_directions = _output_directions
 
         # history_path が与えられた場合、train_history をコンストラクトする
         if history_path is not None:
@@ -54,11 +56,52 @@ class SurrogateModelInterfaceBase(FEMInterface, ABC):
         self.df_prm = df_prm
         self.df_obj = df_obj
 
+        # _output_directions が与えられている場合、
+        # history から objective の設定を読み込む
+        if self._output_directions is not None:
+            self._load_problem_from_me: bool = True
+
         FEMInterface.__init__(
             self,
             train_history=train_history,  # コンストラクト済み train_history を渡せば並列計算時も何もしなくてよい
         )
 
+
+    def load_objective(self, opt) -> None:
+        from pyfemtet.opt._femopt_core import Objective
+
+        assert self._output_directions is not None
+
+        if isinstance(self._output_directions, dict):
+
+            for index, direction in self._output_directions:
+                obj_name = self.train_history.obj_names[index]
+                opt.objectives[obj_name] = Objective(
+                    lambda obj_name_=obj_name: self.obj[obj_name_],
+                    name=obj_name,
+                    direction=direction,
+                    args=(),
+                    kwargs={},
+                )
+
+        elif isinstance(self._output_directions, list) \
+                or isinstance(self._output_directions, tuple):
+
+            obj_names = self.train_history.obj_names
+            assert len(self._output_directions) == len(obj_names)
+
+            for obj_name, direction in zip(obj_names, self._output_directions):
+                opt.objectives[obj_name] = Objective(
+                    lambda obj_name_=obj_name: self.obj[obj_name_],
+                    name=obj_name,
+                    direction=direction,
+                    args=(),
+                    kwargs={},
+                )
+
+        else:
+            raise ValueError('Invalid _output_directions')
+
     def filter_feasible(self, x: np.ndarray, y: np.ndarray, return_feasibility=False):
         feasible_idx = np.where(~np.isnan(y.sum(axis=1)))
         if return_feasibility: