pyfemtet 0.4.21__py3-none-any.whl → 0.4.23__py3-none-any.whl

pyfemtet/opt/opt/_optuna_botorch_helper.py

@@ -0,0 +1,209 @@
+from typing import Optional, List, Tuple, Callable
+from functools import partial
+import inspect
+
+import numpy as np
+import optuna.study
+import torch
+from torch import Tensor
+from botorch.optim.initializers import gen_batch_initial_conditions
+from botorch.utils.transforms import unnormalize
+from optuna.study import Study
+from botorch.acquisition import AcquisitionFunction
+
+from pyfemtet.opt.opt import AbstractOptimizer
+from pyfemtet.opt.parameter import ExpressionEvaluator
+
+# module to monkey patch
+import optuna_integration
+
+
+# モンキーパッチを実行するため、optimize_acqf の引数を MonkyPatch クラスで定義し optuna に上書きされないようにするためのクラス
+class NonOverwritablePartial(partial):
+    def __call__(self, /, *args, **keywords):
+        stored_kwargs = self.keywords
+        keywords.update(stored_kwargs)
+        return self.func(*self.args, *args, **keywords)
+
+
+# prm_name を引数に取る関数を optimize_acqf の nonlinear_inequality_constraints に入れられる形に変換する関数
+class ConvertedConstraintFunction:
+    def __init__(self, fun, prm_args, kwargs, variables: ExpressionEvaluator, study: optuna.study.Study):
+        self.fun = fun
+        self.prm_args = prm_args
+        self.kwargs = kwargs
+        self.variables = variables
+        self.study = study
+
+        self.bounds = None
+        self.prm_name_seq = None
+
+        # fun の prm として使う引数が指定されていなければ fun の引数を取得
+        if self.prm_args is None:
+            signature = inspect.signature(fun)
+            prm_inputs = set([a.name for a in signature.parameters.values()])
+        else:
+            prm_inputs = set(self.prm_args)
+
+        # 引数の set から kwargs の key を削除
+        self.prm_arg_names = prm_inputs - set(kwargs.keys())
+
+        # 変な引数が残っていないか確認
+        assert all([(arg in variables.get_parameter_names()) for arg in self.prm_arg_names])
+
+    def __call__(self, x: Tensor or np.ndarray):
+        # x: all of normalized parameters whose sequence is sorted by optuna
+
+        if not isinstance(x, Tensor):
+            x = torch.tensor(np.array(x)).double()
+
+        x = unnormalize(x, self.bounds)
+
+        # fun で使うパラメータのみ value を取得
+        kwargs = self.kwargs
+        kwargs.update(
+            {k: v for k, v in zip(self.prm_name_seq, x) if k in self.prm_arg_names}
+        )
+
+        return self.fun(**kwargs)
+
+
+# 与えられた獲得関数に拘束を満たさない場合 0 を返すよう加工された獲得関数
+class AcqWithConstraint(AcquisitionFunction):
+
+    # noinspection PyAttributeOutsideInit
+    def set(self, _org_acq_function: AcquisitionFunction, nonlinear_constraints):
+        self._org_acq_function = _org_acq_function
+        self._nonlinear_constraints = nonlinear_constraints
+
+    def forward(self, X: Tensor) -> Tensor:
+        base = self._org_acq_function.forward(X)
+
+        is_feasible = all([cons(X[0][0]) > 0 for cons, _ in self._nonlinear_constraints])
+        if is_feasible:
+            return base
+        else:
+            # penalty = torch.Tensor(size=base.shape)
+            # penalty = torch.fill(penalty, -1e10)
+            # return base * penalty
+            return base * 0.
+
+
+def remove_infeasible(_ic_batch, nonlinear_constraints):
+    # infeasible なものを削除
+    remove_indices = []
+    for i, ic in enumerate(_ic_batch):  # ic: 1 x len(params) tensor
+        # cons: Callable[["Tensor"], "Tensor"]
+        is_feasible = all([cons(ic[0]) > 0 for cons, _ in nonlinear_constraints])
+        if not is_feasible:
+            # ic_batch[i] = torch.nan  # これで無視にならない
+            remove_indices.append(i)
+    for i in remove_indices[::-1]:
+        _ic_batch = torch.cat((_ic_batch[:i], _ic_batch[i + 1:]))
+    return _ic_batch
+
+
+class OptunaBotorchWithParameterConstraintMonkeyPatch:
+
+    def __init__(self, study: Study, opt: AbstractOptimizer):
+        self.num_restarts: int = 20
+        self.raw_samples_additional: int = 512
+        self.eta: float = 2.0
+        self.study = study
+        self.opt = opt
+        self.nonlinear_inequality_constraints = []
+        self.additional_kwargs = dict()
+        self.bounds = None
+        self.prm_name_seq = None
+
+    def add_nonlinear_constraint(self, fun, prm_args, kwargs):
+        f = ConvertedConstraintFunction(
+            fun,
+            prm_args,
+            kwargs,
+            self.opt.variables,
+            self.study,
+        )
+
+        # 初期化
+        self.nonlinear_inequality_constraints = self.nonlinear_inequality_constraints or []
+
+        # 自身に追加
+        self.nonlinear_inequality_constraints.append((f, True))
+
+        # optimize_acqf() に渡す引数に追加
+        self.additional_kwargs.update(
+            nonlinear_inequality_constraints=self.nonlinear_inequality_constraints
+        )
+
+    def _detect_prm_seq_if_needed(self):
+        # study から distribution の情報を復元する。
+        if self.bounds is None or self.prm_name_seq is None:
+            from optuna._transform import _transform_search_space
+            # sample_relative の後に呼ばれているから最後の trial は search_space を持つはず
+            search_space: dict = self.study.sampler.infer_relative_search_space(self.study, self.study.trials[-1])
+            self.bounds = _transform_search_space(search_space, False, False)[0].T
+            self.prm_name_seq = list(search_space.keys())
+
+            for cns in self.nonlinear_inequality_constraints:
+                cns[0].bounds = torch.tensor(self.bounds)
+                cns[0].prm_name_seq = self.prm_name_seq
+
+    def generate_initial_conditions(self, *args, **kwargs):
+        self._detect_prm_seq_if_needed()
+
+        # acqf_function を 上書きし、拘束を満たさないならば 0 を返すようにする
+        org_acq_function = kwargs['acq_function']
+        new_acqf = AcqWithConstraint(None)
+        new_acqf.set(org_acq_function, self.nonlinear_inequality_constraints)
+        kwargs['acq_function'] = new_acqf
+
+        # initial condition の提案 batch を作成
+        # ic: `num_restarts x q x d` tensor of initial conditions.
+        # q = 1, d = len(params)
+        ic_batch = gen_batch_initial_conditions(*args, **kwargs)
+
+        # 拘束を満たさないものを削除
+        ic_batch = remove_infeasible(ic_batch, self.nonlinear_inequality_constraints)
+
+        # 全部なくなっているならばランダムに生成
+        if len(ic_batch) == 0:
+            print('拘束を満たす組み合わせがなかったのでランダムサンプリングします')
+        while len(ic_batch) == 0:
+            size = ic_batch.shape
+            ic_batch = torch.rand(size=[100, *size[1:]])  # 正規化された変数の組合せ
+            ic_batch = remove_infeasible(ic_batch, self.nonlinear_inequality_constraints)
+
+        return ic_batch
+
+    def do_monkey_patch(self):
+        """optuna_integration.botorch には optimize_acqf に constraints を渡す方法が用意されていないので、モンキーパッチして渡す
+
+        モンキーパッチ自体は最適化実行前のどの時点で呼んでも機能するが、additional_kwargs の更新後に
+        モンキーパッチを呼ぶ必要があるのでコンストラクタにこの処理は入れない。
+        各 add_constraint に入れるのはいいかも。
+
+        """
+
+        # === reconstruct argument ``options`` for optimize_acqf ===
+        options = dict()  # initialize
+
+        # for nonlinear-constraint
+        options.update(dict(batch_limit=1))
+
+        # for gen_candidates_scipy()
+        # use COBYLA or SLSQP only.
+        options.update(dict(method='SLSQP'))
+
+        # make partial of optimize_acqf used in optuna_integration.botorch and replace to it.
+        original_fun = optuna_integration.botorch.optimize_acqf
+        overwritten_fun = NonOverwritablePartial(
+            original_fun,
+            q=1,  # for nonlinear constraints
+            options=options,
+            num_restarts=20,  # gen_batch_initial_conditions に渡すべきで、self.generate_initial_conditions に渡される変数。
+            raw_samples=512,  # gen_batch_initial_conditions に渡すべきで、self.generate_initial_conditions に渡される変数。
+            nonlinear_inequality_constraints=self.nonlinear_inequality_constraints,
+            ic_generator=self.generate_initial_conditions,
+        )
+        optuna_integration.botorch.optimize_acqf = overwritten_fun

pyfemtet/opt/visualization/complex_components/main_graph.py

@@ -184,16 +184,18 @@ class MainGraph(AbstractPage):
             # create component
             title_component = html.H3(f"trial{trial}", style={"color": "darkblue"})
             img_component = self.create_image_content_if_femtet(trial)
-            tbl_component = self.create_formatted_parameter(row)
+            tbl_component_prm = self.create_formatted_parameter(row)
+            tbl_component_obj = self.create_formatted_objective(row)
 
             # create layout
             description = html.Div([
                 title_component,
-                tbl_component,
+                tbl_component_prm,
             ])
             tooltip_layout = html.Div([
                 html.Div(img_component, style={'display': 'inline-block', 'margin-right': '10px', 'vertical-align': 'top'}),
-                html.Div(description, style={'display': 'inline-block', 'margin-right': '10px'})
+                html.Div(description, style={'display': 'inline-block', 'margin-right': '10px'}),
+                html.Div(tbl_component_obj, style={'display': 'inline-block', 'margin-right': '10px'}),
             ])
 
             return True, bbox, tooltip_layout
@@ -205,7 +207,22 @@ class MainGraph(AbstractPage):
         names = parameters.columns
         values = [f'{value:.3e}' for value in parameters.values.ravel()]
         data = pd.DataFrame(dict(
-            name=names, value=values
+            parameter=names, value=values
+        ))
+        table = dash_table.DataTable(
+            columns=[{'name': col, 'id': col} for col in data.columns],
+            data=data.to_dict('records')
+        )
+        return table
+
+    def create_formatted_objective(self, row) -> Component:
+        metadata = self.application.history.metadata
+        pd.options.display.float_format = '{:.4e}'.format
+        objectives = row.iloc[:, np.where(np.array(metadata) == 'obj')[0]]
+        names = objectives.columns
+        values = [f'{value:.3e}' for value in objectives.values.ravel()]
+        data = pd.DataFrame(dict(
+            objective=names, value=values
         ))
         table = dash_table.DataTable(
             columns=[{'name': col, 'id': col} for col in data.columns],
@@ -258,5 +275,5 @@ class MainGraph(AbstractPage):
         if isinstance(self.application, ProcessMonitorApplication):
             df = self.application.local_data
         else:
-            df = self.application.history.local_data
+            df = self.application.history.get_df()
         return df

pyfemtet/opt/visualization/complex_components/pm_graph.py

@@ -129,6 +129,19 @@ class PredictionModelGraph(AbstractPage):
         self.slider_stack_data = html.Data(**{self.slider_stack_data_prop: {}})
         self.slider_container = html.Div()
 
+        # 2d or 3d
+        self.switch_3d = dbc.Checklist(
+            options=[
+                dict(
+                    label=Msg.LABEL_SWITCH_PREDICTION_MODEL_3D,
+                    disabled=False,
+                    value=False,
+                )
+            ],
+            switch=True,
+            value=[],
+        )
+
     def setup_layout(self):
         self.card_header = dbc.CardHeader(self.tabs)
 
@@ -151,6 +164,7 @@ class PredictionModelGraph(AbstractPage):
                         self.command_manager
                     ],
                     direction='horizontal', gap=2),
+                self.switch_3d,
                 *dropdown_rows,
                 self.slider_container,
                 self.slider_stack_data,
@@ -193,13 +207,15 @@ class PredictionModelGraph(AbstractPage):
             Output(self.redraw_graph_button_spinner, 'spinner_style', allow_duplicate=True),
             Output(self.redraw_graph_button, 'disabled', allow_duplicate=True),
             Output(self.command_manager, self.command_manager_prop, allow_duplicate=True),
+            Output(self.switch_3d, 'options', allow_duplicate=True),
             Input(self.fit_rsm_button, 'n_clicks'),
             Input(self.redraw_graph_button, 'n_clicks'),
             State(self.fit_rsm_button_spinner, 'spinner_style'),
             State(self.redraw_graph_button_spinner, 'spinner_style'),
+            State(self.switch_3d, 'options'),
             prevent_initial_call=True,
         )
-        def disable_fit_button(_1, _2, state1, state2):
+        def disable_fit_button(_1, _2, state1, state2, switch_options):
             # spinner visibility
             if 'display' in state1.keys(): state1.pop('display')
             if 'display' in state2.keys(): state2.pop('display')
@@ -210,7 +226,12 @@ class PredictionModelGraph(AbstractPage):
             else:
                 command = self.CommandState.redraw.value
 
-            return state1, True, state2, True, command
+            # disable switch
+            option = switch_options[0]
+            option.update({'disabled': True})
+            switch_options[0] = option
+
+            return state1, True, state2, True, command, switch_options
 
         # ===== recreate RSM =====
         @app.callback(
@@ -256,9 +277,10 @@ class PredictionModelGraph(AbstractPage):
             State(self.axis3_obj_dropdown, 'label'),
             State(self.slider_container, 'children'),  # for callback chain
             State({'type': 'prm-slider', 'index': ALL}, 'value'),
+            State(self.switch_3d, 'value'),
             prevent_initial_call=True,
         )
-        def redraw_graph(command, active_tab_id, axis1_label, axis2_label, axis3_label, _2, prm_values):
+        def redraw_graph(command, active_tab_id, axis1_label, axis2_label, axis3_label, _2, prm_values, is_3d):
             # just in case
             if callback_context.triggered_id is None:
                 raise PreventUpdate
@@ -283,6 +305,9 @@ class PredictionModelGraph(AbstractPage):
                 logger.error(Msg.ERR_NO_PREDICTION_MODEL)
                 return no_update, self.CommandState.ready.value  # to re-enable buttons, fire callback chain
 
+            if not is_3d:
+                axis2_label = None
+
             # get indices to remove
             idx1 = prm_names.index(axis1_label) if axis1_label in prm_names else None
             idx2 = prm_names.index(axis2_label) if axis2_label in prm_names else None
@@ -307,23 +332,31 @@ class PredictionModelGraph(AbstractPage):
 
             return fig, self.CommandState.ready.value
 
-        # ===== When the graph is updated, enable buttons =====
+        # ===== re-enable buttons when the graph is updated,  =====
         @app.callback(
             Output(self.fit_rsm_button, 'disabled', allow_duplicate=True),
             Output(self.fit_rsm_button_spinner, 'spinner_style', allow_duplicate=True),
             Output(self.redraw_graph_button, 'disabled', allow_duplicate=True),
             Output(self.redraw_graph_button_spinner, 'spinner_style', allow_duplicate=True),
+            Output(self.switch_3d, 'options', allow_duplicate=True),
             Input(self.command_manager, self.command_manager_prop),
             State(self.fit_rsm_button_spinner, 'spinner_style'),
             State(self.redraw_graph_button_spinner, 'spinner_style'),
+            State(self.switch_3d, 'options'),
             prevent_initial_call=True,
         )
-        def enable_buttons(command, state1, state2):
+        def enable_buttons(command, state1, state2, switch_options):
             if command != self.CommandState.ready.value:
                 raise PreventUpdate
             state1.update({'display': 'none'})
             state2.update({'display': 'none'})
-            return False, state1, False, state2
+
+            # enable switch
+            option = switch_options[0]
+            option.update({'disabled': False})
+            switch_options[0] = option
+
+            return False, state1, False, state2, switch_options
 
         # ===== setup dropdown and sliders from history =====
         @app.callback(
@@ -414,6 +447,7 @@ class PredictionModelGraph(AbstractPage):
             Input({'type': 'axis2-dropdown-menu-item', 'index': ALL}, 'n_clicks'),
             Input({'type': 'axis3-dropdown-menu-item', 'index': ALL}, 'n_clicks'),
             Input(self.axis1_prm_dropdown, 'children'),  # for callback chain timing
+            Input(self.switch_3d, 'value'),
             State(self.axis1_prm_dropdown, 'label'),
             State(self.axis2_prm_dropdown, 'label'),
             State(self.axis3_obj_dropdown, 'label'),
@@ -422,10 +456,10 @@ class PredictionModelGraph(AbstractPage):
         )
         def update_controller(*args):
             # argument processing
-            current_ax1_label = args[4]
-            current_ax2_label = args[5]
-            # current_ax3_label = args[6]
-            current_styles: list[dict] = args[7]
+            current_ax1_label = args[5]
+            current_ax2_label = args[6]
+            current_styles: list[dict] = args[8]
+            is_3d = args[4]
 
             # just in case
             if callback_context.triggered_id is None:
@@ -451,6 +485,10 @@ class PredictionModelGraph(AbstractPage):
             if len(prm_names) < 2:
                 ret[ax2_hidden] = True
 
+            # ===== hide dropdown of axis 2 if not is_3d =====
+            if not is_3d:
+                ret[ax2_hidden] = True
+
             # ===== update dropdown label =====
 
             # by callback chain on loaded after setup_dropdown_and_sliders()
@@ -466,29 +504,43 @@ class PredictionModelGraph(AbstractPage):
 
                 # ax1
                 if callback_context.triggered_id['type'] == 'axis1-dropdown-menu-item':
-                    if new_label != current_ax2_label:
-                        ret[ax1_label_key] = new_label
-                    else:
-                        logger.error(Msg.ERR_CANNOT_SELECT_SAME_PARAMETER)
+                    ret[ax1_label_key] = new_label
+                    if new_label == current_ax2_label:
+                        ret[ax2_label_key] = current_ax1_label
+
 
                 # ax2
                 elif callback_context.triggered_id['type'] == 'axis2-dropdown-menu-item':
-                    if new_label != current_ax1_label:
-                        ret[ax2_label_key] = new_label
-                    else:
-                        logger.error(Msg.ERR_CANNOT_SELECT_SAME_PARAMETER)
+                    ret[ax2_label_key] = new_label
+                    if new_label == current_ax1_label:
+                        ret[ax1_label_key] = current_ax2_label
+
 
                 # ax3
                 elif callback_context.triggered_id['type'] == 'axis3-dropdown-menu-item':
                     ret[ax3_label_key] = new_label
 
             # ===== update visibility of sliders =====
-            for label_key, current_label in zip((ax1_label_key, ax2_label_key), (current_ax1_label, current_ax2_label)):
-                # get label of output
-                label = ret[label_key] if ret[label_key] != no_update else current_label
-                # update display style of slider
-                idx = prm_names.index(label) if label in prm_names else None
-                if idx is not None:
+
+            # invisible the slider correspond to the dropdown-1
+            label_key, current_label = ax1_label_key, current_ax1_label
+            # get label of output
+            label = ret[label_key] if ret[label_key] != no_update else current_label
+            # update display style of slider
+            idx = prm_names.index(label) if label in prm_names else None
+            if idx is not None:
+                current_styles[idx].update({'display': 'none'})
+                ret[slider_style_list_key][idx] = current_styles[idx]
+
+            # invisible the slider correspond to the dropdown-2
+            label_key, current_label = ax2_label_key, current_ax2_label
+            # get label of output
+            label = ret[label_key] if ret[label_key] != no_update else current_label
+            # update display style of slider
+            idx = prm_names.index(label) if label in prm_names else None
+            if idx is not None:
+                # if 2d, should not disable the slider correspond to dropdown-2.
+                if is_3d:
                     current_styles[idx].update({'display': 'none'})
                     ret[slider_style_list_key][idx] = current_styles[idx]
 
@@ -554,5 +606,5 @@ class PredictionModelGraph(AbstractPage):
         if isinstance(self.application, ProcessMonitorApplication):
             df = self.application.local_data
         else:
-            df = self.application.history.local_data
+            df = self.application.history.get_df()
         return df

pyfemtet/opt/visualization/complex_components/pm_graph_creator.py

@@ -183,4 +183,11 @@ class PredictionModelCreator:
                 )
             )
 
+            # layout
+            fig.update_layout(
+                title=Msg.GRAPH_TITLE_PREDICTION_MODEL,
+                xaxis_title=prm_name_1,
+                yaxis_title=obj_name,
+            )
+
         return fig

pyfemtet/opt/visualization/process_monitor/application.py

@@ -5,7 +5,7 @@ from threading import Thread
 import pandas as pd
 
 from pyfemtet.opt.visualization.base import PyFemtetApplicationBase, logger
-from pyfemtet.opt.visualization.process_monitor.pages import HomePage, WorkerPage, PredictionModelPage
+from pyfemtet.opt.visualization.process_monitor.pages import HomePage, WorkerPage, PredictionModelPage, OptunaVisualizerPage
 from pyfemtet.message import Msg
 
 
@@ -67,14 +67,14 @@ class ProcessMonitorApplication(PyFemtetApplicationBase):
         if self._should_get_actor_data:
             return self._df
         else:
-            return self.history.local_data
+            return self.history.get_df()
 
     @local_data.setter
     def local_data(self, value: pd.DataFrame):
         if self._should_get_actor_data:
             raise NotImplementedError('If should_get_actor_data, ProcessMonitorApplication.local_df is read_only.')
         else:
-            self.history.local_data = value
+            self.history.set_df(value)
 
     def setup_callback(self, debug=False):
         if not debug:
@@ -112,7 +112,7 @@ class ProcessMonitorApplication(PyFemtetApplicationBase):
                     worker_status.set(OptimizationStatus.INTERRUPTING)
 
             # status と df を actor から application に反映する
-            self._df = self.history.actor_data.copy()
+            self._df = self.history.get_df().copy()
             self.local_entire_status_int = self.entire_status.get()
             self.local_worker_status_int_list = [s.get() for s in self.worker_status_list]
 
@@ -176,11 +176,13 @@ def g_debug():
 
     g_home_page = HomePage(Msg.PAGE_TITLE_PROGRESS)
     g_rsm_page = PredictionModelPage(Msg.PAGE_TITLE_PREDICTION_MODEL, '/prediction-model', g_application)
+    g_optuna = OptunaVisualizerPage(Msg.PAGE_TITLE_OPTUNA_VISUALIZATION, '/optuna', g_application)
     g_worker_page = WorkerPage(Msg.PAGE_TITLE_WORKERS, '/workers', g_application)
 
     g_application.add_page(g_home_page, 0)
     g_application.add_page(g_rsm_page, 1)
-    g_application.add_page(g_worker_page, 2)
+    g_application.add_page(g_optuna, 2)
+    g_application.add_page(g_worker_page, 3)
     g_application.setup_callback(debug=False)
 
     g_application.run(debug=False)
@@ -191,11 +193,13 @@ def main(history, status, worker_addresses, worker_status_list, host=None, port=
 
     g_home_page = HomePage(Msg.PAGE_TITLE_PROGRESS)
     g_rsm_page = PredictionModelPage(Msg.PAGE_TITLE_PREDICTION_MODEL, '/prediction-model', g_application)
+    g_optuna = OptunaVisualizerPage(Msg.PAGE_TITLE_OPTUNA_VISUALIZATION, '/optuna', g_application)
     g_worker_page = WorkerPage(Msg.PAGE_TITLE_WORKERS, '/workers', g_application)
 
     g_application.add_page(g_home_page, 0)
     g_application.add_page(g_rsm_page, 1)
-    g_application.add_page(g_worker_page, 2)
+    g_application.add_page(g_optuna, 2)
+    g_application.add_page(g_worker_page, 3)
     g_application.setup_callback()
 
     g_application.start_server(host, port)

pyfemtet/opt/visualization/process_monitor/pages.py

@@ -1,6 +1,8 @@
 import numpy as np
 import pandas as pd
 
+import optuna
+
 from dash import Output, Input, State, callback_context, no_update, ALL
 from dash.exceptions import PreventUpdate
 
@@ -289,3 +291,103 @@ class PredictionModelPage(AbstractPage):
 
     def setup_layout(self):
         self.layout = self.rsm_graph.layout
+
+
+class OptunaVisualizerPage(AbstractPage):
+
+    def __init__(self, title, rel_url, application):
+        from pyfemtet.opt.visualization.process_monitor.application import ProcessMonitorApplication
+        self.application: ProcessMonitorApplication = None
+        super().__init__(title, rel_url, application)
+
+    def setup_component(self):
+        self.location = dcc.Location(id='optuna-page-location', refresh=True)
+        self._layout = html.Div(children=[Msg.DETAIL_PAGE_TEXT_BEFORE_LOADING])
+        self.layout = [self.location, self._layout]
+
+    def _setup_layout(self):
+
+        study = self.application.history.create_optuna_study()
+        prm_names = self.application.history.prm_names
+        obj_names = self.application.history.obj_names
+
+        layout = []
+
+        layout.append(html.H2(Msg.DETAIL_PAGE_HISTORY_HEADER))
+        layout.append(html.H4(Msg.DETAIL_PAGE_HISTORY_DESCRIPTION))
+        for i, obj_name in enumerate(obj_names):
+            fig = optuna.visualization.plot_optimization_history(
+                study,
+                target=lambda t: t.values[i],
+                target_name=obj_name
+            )
+            layout.append(dcc.Graph(figure=fig, style={'height': '70vh'}))
+
+        layout.append(html.H2(Msg.DETAIL_PAGE_PARALLEL_COOR_HEADER))
+        layout.append(html.H4(Msg.DETAIL_PAGE_PARALLEL_COOR_DESCRIPTION))
+        for i, obj_name in enumerate(obj_names):
+            fig = optuna.visualization.plot_parallel_coordinate(
+                study,
+                target=lambda t: t.values[i],
+                target_name=obj_name
+            )
+            layout.append(dcc.Graph(figure=fig, style={'height': '70vh'}))
+
+        layout.append(html.H2(Msg.DETAIL_PAGE_CONTOUR_HEADER))
+        layout.append(html.H4(Msg.DETAIL_PAGE_CONTOUR_DESCRIPTION))
+        for i, obj_name in enumerate(obj_names):
+            fig = optuna.visualization.plot_contour(
+                study,
+                target=lambda t: t.values[i],
+                target_name=obj_name
+            )
+            layout.append(dcc.Graph(figure=fig, style={'height': '90vh'}))
+
+        # import itertools
+        # for (i, j) in itertools.combinations(range(len(obj_names)), 2):
+        #     fig = optuna.visualization.plot_pareto_front(
+        #         study,
+        #         targets=lambda t: (t.values[i], t.values[j]),
+        #         target_names=[obj_names[i], obj_names[j]],
+        #     )
+        #     self.graphs.append(dcc.Graph(figure=fig, style={'height': '50vh'}))
+
+        layout.append(html.H2(Msg.DETAIL_PAGE_SLICE_HEADER))
+        layout.append(html.H4(Msg.DETAIL_PAGE_SLICE_DESCRIPTION))
+        for i, obj_name in enumerate(obj_names):
+            fig = optuna.visualization.plot_slice(
+                study,
+                target=lambda t: t.values[i],
+                target_name=obj_name
+            )
+            layout.append(dcc.Graph(figure=fig, style={'height': '70vh'}))
+
+        return layout
+
+    def setup_callback(self):
+        app = self.application.app
+
+        @app.callback(
+            Output(self._layout, 'children'),
+            Input(self.location, 'pathname'),  # on page load
+        )
+        def update_page(_):
+            if self.application.history is None:
+                return Msg.ERR_NO_HISTORY_SELECTED
+
+            if len(self.data_accessor()) == 0:
+                return Msg.ERR_NO_FEM_RESULT
+
+            return self._setup_layout()
+
+
+    def setup_layout(self):
+        pass
+
+    def data_accessor(self) -> pd.DataFrame:
+        from pyfemtet.opt.visualization.process_monitor.application import ProcessMonitorApplication
+        if isinstance(self.application, ProcessMonitorApplication):
+            df = self.application.local_data
+        else:
+            df = self.application.history.local_data
+        return df