pyfemtet 0.4.9__py3-none-any.whl → 0.4.11__py3-none-any.whl

pyfemtet/opt/visualization/complex_components/main_graph.py

@@ -0,0 +1,263 @@
+# type hint
+from dash.development.base_component import Component
+
+# callback
+from dash import Output, Input, State, no_update, callback_context
+from dash.exceptions import PreventUpdate
+
+# components
+from dash import dash_table
+from pyfemtet.opt.visualization.wrapped_components import html, dcc, dbc
+
+# graph
+import pandas as pd
+# import plotly.express as px
+import plotly.graph_objs as go
+
+# the others
+import os
+import base64
+import json
+import numpy as np
+
+from pyfemtet.opt.visualization.complex_components import main_figure_creator
+from pyfemtet.opt.visualization.base import PyFemtetApplicationBase, AbstractPage, logger
+
+
+FLEXBOX_STYLE_ALLOW_VERTICAL_FILL = {
+    'display': 'flex',
+    'flex-direction': 'column',
+    'flex-grow': '1',
+}
+
+
+# noinspection PyAttributeOutsideInit
+class MainGraph(AbstractPage):
+    """"""
+    """
+    +=================+
+    |tab1|tab2|       | <- CardHeader
+    |    +------------+
+    | +-------------+ |
+    | | Loading     | | <- CardBody
+    | | +---------+ | |
+    | | |  graph <-------- ToolTip
+    | | +---------+ | |
+    | +-------------+ |
+    +=================+
+
+        Data(data-selection)
+
+    """
+
+    def __init__(self):
+        self.setup_figure_creator()
+        super().__init__()
+
+    def setup_figure_creator(self):
+        # setup figure creators
+        # list[0] is the default tab
+        self.figure_creators = [
+            dict(
+                tab_id='tab-objective-plot',
+                label='objectives',
+                creator=main_figure_creator.get_default_figure,
+            ),
+            dict(
+                tab_id='tab-hypervolume-plot',
+                label='hypervolume',
+                creator=main_figure_creator.get_hypervolume_plot,
+            ),
+        ]
+
+    def setup_component(self):
+        self.dummy = html.Div(id='main-graph-dummy')
+        self.location = dcc.Location(id='main-graph-location', refresh=True)
+
+        # setup header
+        self.tab_list = [dbc.Tab(label=d['label'], tab_id=d['tab_id']) for d in self.figure_creators]
+        self.tabs = dbc.Tabs(self.tab_list, id='main-graph-tabs')
+        self.card_header = dbc.CardHeader(self.tabs)
+
+        # setup body
+        self.tooltip = dcc.Tooltip(id='main-graph-tooltip')
+
+        # set kwargs of Graph to reconstruct Graph in ProcessMonitor.
+        self.graph_kwargs = dict(
+            id='main-graph',
+            # animate=True,  # THIS CAUSE THE UPDATED DATA / NOT-UPDATED FIGURE STATE.
+            clear_on_unhover=True,
+            style={
+                # 'flex-grow': '1',  # Uncomment if the plotly's specification if fixed, and we can use dcc.Graph with FlexBox.
+                'height': '60vh',
+            },
+            figure=go.Figure()
+        )
+
+        self.graph: dcc.Graph = dcc.Graph(
+            **self.graph_kwargs
+        )  # Graph make an element by js, so Flexbox CSS cannot apply to the graph (The element can be bigger, but cannot be smaller.)
+
+        self.loading = dcc.Loading(
+            children=self.graph,
+            id='loading-main-graph',
+        )  # Loading make an element that doesn't contain a style attribute, so Flexbox CSS cannot apply to the graph
+
+        self.card_body = dbc.CardBody(
+            children=html.Div([self.loading, self.tooltip]),  # If list is passed to CardBody's children, create element that doesn't contain a style attribute, so Flexbox CSS cannot apply to graph
+            id='main-graph-card-body',
+            # style=FLEXBOX_STYLE_ALLOW_VERTICAL_FILL,
+        )
+
+        # setup selection data
+        self.selection_data_property = 'data-selection'  # must be starts with "data-"
+        self.selection_data = html.Data(id='selection-data', **{self.selection_data_property: {}})
+
+        # set data length
+        self.data_length_prop = 'data-df-length'  # must start with "data-"
+        self.data_length = html.Data(id='df-length-data', **{self.data_length_prop: None})
+
+    def setup_layout(self):
+        # setup component
+        self.graph_card = dbc.Card(
+            [
+                self.dummy,
+                self.location,
+                self.data_length,
+                self.card_header,
+                self.card_body,
+                self.selection_data,
+            ],
+            # style=FLEXBOX_STYLE_ALLOW_VERTICAL_FILL,
+        )
+
+        self.layout = self.graph_card
+
+    def setup_callback(self):
+        # setup callback of subpages
+        super().setup_callback()
+
+        app = self.application.app
+
+        # ===== Update Graph =====
+        @app.callback(
+            Output(self.graph.id, 'figure'),
+            Output(self.data_length.id, self.data_length_prop),  # To determine whether Process Monitor should update the graph, the main graph remembers the current amount of data.
+            Input(self.tabs.id, 'active_tab'),
+            Input(self.dummy, 'children'),
+            prevent_initial_call=False,)
+        def redraw_main_graph(active_tab_id, _):
+            logger.debug('====================')
+            logger.debug(f'redraw_main_graph called by {callback_context.triggered_id}')
+            figure, length = self.get_fig_by_tab_id(active_tab_id, with_length=True)
+            return figure, length
+
+        # ===== Save Selection =====
+        @app.callback(
+            Output(self.selection_data.id, self.selection_data_property),
+            Input(self.graph.id, 'selectedData'))
+        def save_selection(data):
+            return data
+
+        # ===== Show Image and Parameter on Hover =====
+        @app.callback(
+            Output(self.tooltip.id, "show"),
+            Output(self.tooltip.id, "bbox"),
+            Output(self.tooltip.id, "children"),
+            Input(self.graph.id, "hoverData"),)
+        def show_hover(hoverData):
+            if hoverData is None:
+                return False, no_update, no_update
+
+            if self.application.history is None:
+                raise PreventUpdate
+
+            # get hover location
+            pt = hoverData["points"][0]
+            bbox = pt["bbox"]
+
+            # get row of the history from customdata defined in main_figure
+            trial = pt['customdata'][0]
+
+            df = self.data_accessor()
+            row = df[df['trial'] == trial]
+
+            # 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)
+
+            # create layout
+            description = html.Div([
+                title_component,
+                tbl_component,
+            ])
+            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'})
+            ])
+
+            return True, bbox, tooltip_layout
+
+    def create_formatted_parameter(self, row) -> Component:
+        metadata = self.application.history.metadata
+        pd.options.display.float_format = '{:.4e}'.format
+        parameters = row.iloc[:, np.where(np.array(metadata) == 'prm')[0]]
+        names = parameters.columns
+        values = [f'{value:.3e}' for value in parameters.values.ravel()]
+        data = pd.DataFrame(dict(
+            name=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_image_content_if_femtet(self, trial) -> Component:
+        img_url = None
+        metadata = self.application.history.metadata
+        if metadata[0] != '':
+            # get img path
+            d = json.loads(metadata[0])
+            femprj_path = d['femprj_path']
+            model_name = d['model_name']
+            femprj_result_dir = femprj_path.replace('.femprj', '.Results')
+            img_path = os.path.join(femprj_result_dir, f'{model_name}_trial{trial}.jpg')
+            if os.path.exists(img_path):
+                # create encoded image
+                with open(img_path, 'rb') as f:
+                    content = f.read()
+                encoded_image = base64.b64encode(content).decode('utf-8')
+                img_url = 'data:image/jpeg;base64, ' + encoded_image
+        return html.Img(src=img_url, style={"width": "200px"}) if img_url is not None else html.Div()
+
+    def get_fig_by_tab_id(self, tab_id, with_length=False):
+        # If the history is not loaded, do nothing
+        if self.application.history is None:
+            raise PreventUpdate
+
+        # else, get creator by tab_id
+        if tab_id == 'default':
+            creator = self.figure_creators[0]['creator']
+        else:
+            creators = [d['creator'] for d in self.figure_creators if d['tab_id'] == tab_id]
+            if len(creators) == 0:
+                raise PreventUpdate
+            creator = creators[0]
+
+        # create figure
+        df = self.data_accessor()
+        fig = creator(self.application.history, df)
+        if with_length:
+            return fig, len(df)
+        else:
+            return fig
+
+    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

pyfemtet/opt/visualization/process_monitor/application.py

@@ -0,0 +1,201 @@
+from typing import List
+from time import sleep
+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
+
+
+class ProcessMonitorApplication(PyFemtetApplicationBase):
+    """"""
+    """
+        +------+--------+
+        | side | con-   |
+        | bar  | tent   |
+        +--^---+--^-----+
+           │      └─ pages (dict(href: str = layout: Component))
+           └──────── nav_links (dict(order: float) = NavLink)
+
+        Accessible members:
+        - history: History
+           └ local_df: pd.DataFrame
+        - app: Dash
+        - local_entire_status_int: int  <----------------> femopt.statue: OptimizationStatus(Actor)
+        - local_worker_status_int_list: List[int]  <-----> femopt.opt.statue: List[OptimizationStatus(Actor)]
+                                                     ^
+                                                     |
+                                   sync "while" statement in start_server()
+    """
+
+    DEFAULT_PORT = 8080
+
+    def __init__(
+            self,
+            history,
+            status,
+            worker_addresses,
+            worker_status_list,
+            is_debug=False,
+    ):
+        super().__init__(
+            title='PyFemtet Monitor',
+            subtitle='visualize optimization progress',
+            history=history,
+        )
+
+        self._should_get_actor_data = False
+        self.is_debug = is_debug
+
+        # type hint (avoid circular import)
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+
+        # register arguments
+        self.worker_addresses: List[str] = worker_addresses
+        self.entire_status: OptimizationStatus = status  # include actor
+        self.worker_status_list: List[OptimizationStatus] = worker_status_list  # include actor
+
+        # initialize local members (from actors)
+        self._df: pd.DataFrame = self.local_data
+        self.local_entire_status_int: int = self.entire_status.get()
+        self.local_worker_status_int_list: List[int] = [s.get() for s in self.worker_status_list]
+
+    @property
+    def local_data(self) -> pd.DataFrame:
+        if self._should_get_actor_data:
+            return self._df
+        else:
+            return self.history.local_data
+
+
+    @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
+
+
+    def setup_callback(self, debug=False):
+        if not debug:
+            super().setup_callback()
+
+    def start_server(self, host=None, port=None):
+        """Callback の中で使いたい Actor のデータを Application クラスのメンバーとやり取りしつつ、server を落とす関数"""
+
+        self._should_get_actor_data = True
+
+        # avoid circular import
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+
+        host = host or 'localhost'
+        port = port or self.DEFAULT_PORT
+
+        # dash app server を daemon thread で起動
+        server_thread = Thread(
+            target=self.run,
+            args=(host, port,),
+            daemon=True,
+        )
+        server_thread.start()
+
+        # dash app (=flask server) の callback で dask の actor にアクセスすると
+        # おかしくなることがあるので、ここで必要な情報のみやり取りする
+        while True:
+            # running 以前に monitor で current status を interrupting にしていれば actor に反映
+            if (
+                    (self.entire_status.get() <= OptimizationStatus.RUNNING)  # メインプロセスが RUNNING 以前である
+                    and (self.local_entire_status_int == OptimizationStatus.INTERRUPTING)  # Application で status を INTERRUPT にした
+            ):
+                self.entire_status.set(OptimizationStatus.INTERRUPTING)
+                for worker_status in self.worker_status_list:
+                    worker_status.set(OptimizationStatus.INTERRUPTING)
+
+            # status と df を actor から application に反映する
+            self._df = self.history.actor_data.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]
+
+            # terminate_all 指令があれば flask server をホストするプロセスごと終了する
+            if self.entire_status.get() >= OptimizationStatus.TERMINATE_ALL:
+                return 0  # take server down with me
+
+            # interval
+            sleep(1)
+
+    def get_status_color(self, status_int):
+        from pyfemtet.opt._femopt_core import OptimizationStatus
+        # set color
+        if status_int <= OptimizationStatus.SETTING_UP:
+            color = 'secondary'
+        elif status_int <= OptimizationStatus.WAIT_OTHER_WORKERS:
+            color = 'primary'
+        elif status_int <= OptimizationStatus.RUNNING:
+            color = 'primary'
+        elif status_int <= OptimizationStatus.INTERRUPTING:
+            color = 'warning'
+        elif status_int <= OptimizationStatus.TERMINATE_ALL:
+            color = 'dark'
+        elif status_int <= OptimizationStatus.CRASHED:
+            color = 'danger'
+        else:
+            color = 'danger'
+        return color
+
+
+def g_debug():
+    import os
+    os.chdir(os.path.dirname(__file__))
+
+    from pyfemtet.opt._femopt_core import History, OptimizationStatus
+
+    class _OS(OptimizationStatus):
+
+        # noinspection PyMissingConstructor
+        def __init__(self, name):
+            self.name = name
+            self.st = self.INITIALIZING
+
+        def set(self, status_const):
+            self.st = status_const
+
+        def get(self) -> int:
+            return self.st
+
+        def get_text(self) -> int:
+            return self.const_to_str(self.st)
+
+    g_application = ProcessMonitorApplication(
+        history=History(history_path=os.path.join(os.path.dirname(__file__), '..', 'result_viewer', 'sample', 'sample.csv')),
+        status=_OS('entire'),
+        worker_addresses=['worker1', 'worker2', 'worker3'],
+        worker_status_list=[_OS('worker1'), _OS('worker2'), _OS('worker3')],
+        is_debug=True,
+    )
+
+    g_home_page = HomePage('Progress')
+    g_worker_page = WorkerPage('Workers', '/workers', g_application)
+
+    g_application.add_page(g_home_page, 0)
+    g_application.add_page(g_worker_page, 1)
+    g_application.setup_callback(debug=False)
+
+    g_application.run(debug=True)
+
+
+def main(history, status, worker_addresses, worker_status_list, host=None, port=None):
+    g_application = ProcessMonitorApplication(history, status, worker_addresses, worker_status_list)
+
+    g_home_page = HomePage('Progress')
+    g_worker_page = WorkerPage('Workers', '/workers', g_application)
+
+    g_application.add_page(g_home_page, 0)
+    g_application.add_page(g_worker_page, 1)
+    g_application.setup_callback()
+
+    g_application.start_server(host, port)
+
+
+if __name__ == '__main__':
+    g_debug()