pyfemtet 0.9.5__py3-none-any.whl → 1.0.0b0__py3-none-any.whl

pyfemtet/opt/visualization/_complex_components/pm_graph_creator.py

@@ -1,201 +0,0 @@
-from typing import Callable, List
-
-import torch
-import numpy as np
-import pandas as pd
-
-import plotly.graph_objs as go
-import plotly.express as px
-
-from pyfemtet.opt._femopt_core import History
-
-from pyfemtet.opt.prediction._base import PyFemtetPredictionModel
-from pyfemtet.opt.prediction.single_task_gp import SingleTaskGPModel
-from pyfemtet._message import Msg
-
-
-class PredictionModelCreator:
-
-    # noinspection PyAttributeOutsideInit
-    def fit(self, history, df):
-        # common
-        self.history = history  # used to check fit or not
-        self.df = df
-        # method specific
-        self.pmm = PyFemtetPredictionModel(history, df, SingleTaskGPModel)
-        self.pmm.fit()
-
-    def create_figure(
-            self,
-            prm_name_1: str,
-            obj_name: str,
-            remaining_x: list[float],
-            prm_name_2: str = '',
-    ):
-
-        history = self.history
-        df = self.df
-
-        # determine axis1, axis2 range
-        lb1 = df[f'{prm_name_1}_lower_bound'].min()
-        ub1 = df[f'{prm_name_1}_upper_bound'].max()
-        lb1 = df[prm_name_1].min() if np.isnan(lb1) else lb1
-        ub1 = df[prm_name_1].max() if np.isnan(ub1) else ub1
-        if prm_name_2:
-            lb2 = df[f'{prm_name_2}_lower_bound'].min()
-            ub2 = df[f'{prm_name_2}_upper_bound'].max()
-            lb2 = df[prm_name_2].min() if np.isnan(lb2) else lb2
-            ub2 = df[prm_name_2].max() if np.isnan(ub2) else ub2
-
-        # create grid data
-        if prm_name_2:
-            N = 20
-            x_grid = np.linspace(lb1, ub1, N)  # shape: (N,)
-            y_grid = np.linspace(lb2, ub2, N)
-            xx, yy = np.meshgrid(x_grid, y_grid)  # shape: (N, N)
-        else:
-            N = 100
-            xx = np.linspace(lb1, ub1, N)  # shape: (N,)
-
-        # create raveled grid data
-        tmp_df = pd.DataFrame(
-            columns=history.prm_names,
-            index=range(len(xx.ravel())),  # index で df の長さを指定しないと remaining_x の代入で工夫が必要になる
-        )
-
-        # 変数名ごとに見ていって、
-        # 横軸に使う変数ならグリッド値を入れ、
-        # そうでなければ remaining_x の値を入れる（シリーズになる）
-        idx = 0
-        for prm_name in history.prm_names:
-            if prm_name == prm_name_1:
-                tmp_df[prm_name_1] = xx.ravel()  # shape: (N**2,) or (N,)
-            elif prm_name == prm_name_2:  # no chance to hit if prm_name_2 == ''
-                tmp_df[prm_name_2] = yy.ravel()
-            else:
-                tmp_df[prm_name] = remaining_x[idx]
-                idx += 1
-        x = tmp_df.values  # shape: (len(prm), N**2)
-
-        # predict by model
-        mean, std = self.pmm.predict(x)  # shape: (len(obj), N**2)
-
-        # create mesh data for graph
-        obj_index = history.obj_names.index(obj_name)
-        zz_mean = mean[:, obj_index].reshape(xx.shape)  # shape: (N**2,) -> (N, N) or (N,) -> (N,)
-        zz_std = std[:, obj_index].reshape(xx.shape)
-        zz_upper = zz_mean + zz_std
-        zz_lower = zz_mean - zz_std
-
-        # ===== create figure =====
-        # description: データ点は多次元空間上の点なので、余剰次元を無視して三次元空間上に投影しても何の意味もない。むしろ混乱するのでやってはいけない。実験的機能として、透明度を設定してみる。
-        # calculate distance from super-plane to prm point for opacity of scatter plot
-        remaining_prm = list(history.prm_names)  # weak copy
-        remaining_prm.remove(prm_name_1)
-        remaining_prm.remove(prm_name_2) if prm_name_2 in remaining_prm else None
-        if len(remaining_prm) > 0:
-            super_plane = np.array(remaining_x)  # shape: (len(prm_names)-2) or (len(prm_names)-1)
-            target_point = df[remaining_prm].values  # shape: (len(df), len(prm_names)-2) or (len(df), len(prm_names)-1)
-            distance = np.linalg.norm(target_point-super_plane, axis=1, keepdims=False)  # shape: (len(df))
-            opacity = 1 - (distance / distance.max())  # smaller distance, larger opacity
-        else:
-            opacity = np.ones(len(df))
-
-        # scatter plot
-        if prm_name_2:
-            fig = go.Figure(data=go.Scatter3d(
-                x=df[prm_name_1], y=df[prm_name_2], z=df[obj_name],
-                mode='markers',
-                marker=dict(
-                    size=3,
-                    line=dict(
-                        width=1,  # broken?
-                        color='white',
-                        # color=df['trial'],  # 見づらい？
-                        # colorscale='Viridis_r',
-                    ),
-                ),
-                name='trial',
-            ))
-        else:
-            fig = go.Figure(data=go.Scatter(
-                x=df[prm_name_1], y=df[obj_name],
-                mode='markers',
-                marker=dict(
-                    line=dict(
-                        width=1,
-                        color='white',
-                    ),
-                ),
-                name='trial',
-            ))
-
-        # set opacity by its distance
-        def set_opacity(trace):
-            trace.marker.color = [f'rgba(0, 0, 0, {o: .2f})' for o in opacity]
-        fig.for_each_trace(set_opacity)
-
-        # main RSM
-        if prm_name_2:
-            contours = dict(
-                x=dict(
-                    highlight=True, show=True, color='blue',
-                    start=lb1, end=ub1, size=(ub1-lb1)/N,
-                ),
-                y=dict(
-                    highlight=True, show=True, color='blue',
-                    start=lb2, end=ub2, size=(ub2-lb2)/N
-                ),
-                z=dict(highlight=False, show=False),
-            )
-            fig.add_trace(
-                go.Surface(
-                    z=zz_mean, x=xx, y=yy,
-                    contours=contours,
-                    showlegend=True,
-                    name=Msg.LEGEND_LABEL_PREDICTION_MODEL,
-                    colorbar=dict(
-                        x=0.2,
-                        xref="container",
-                        # orientation='h',
-                    )
-                )
-            )
-            # std
-            fig.add_trace(go.Surface(z=zz_upper, x=xx, y=yy, showscale=False, opacity=0.3, showlegend=True, name=Msg.LEGEND_LABEL_PREDICTION_MODEL_STDDEV))
-            fig.add_trace(go.Surface(z=zz_lower, x=xx, y=yy, showscale=False, opacity=0.3, showlegend=True, name=Msg.LEGEND_LABEL_PREDICTION_MODEL_STDDEV))
-
-            # layout
-            fig.update_layout(
-                title=Msg.GRAPH_TITLE_PREDICTION_MODEL,
-                scene=dict(
-                    xaxis_title=prm_name_1,
-                    yaxis_title=prm_name_2,
-                    zaxis_title=obj_name
-                ),
-                margin=dict(l=0, r=0, b=0, t=30),
-            )
-
-        else:
-            fig.add_trace(
-                go.Scatter(x=xx, y=zz_mean, name=Msg.LEGEND_LABEL_PREDICTION_MODEL)
-            )
-            # std
-            fig.add_trace(
-                go.Scatter(
-                    x=np.concatenate([xx, xx[::-1]]),
-                    y=np.concatenate([zz_upper, zz_lower[::-1]]),
-                    opacity=0.3,
-                    fill='toself',
-                    name=Msg.LEGEND_LABEL_PREDICTION_MODEL_STDDEV,
-                )
-            )
-
-            # 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

@@ -1,226 +0,0 @@
-from typing import List
-from time import sleep
-from threading import Thread
-
-import pandas as pd
-from flask import jsonify
-
-from pyfemtet.opt.visualization._base import PyFemtetApplicationBase, logger
-from pyfemtet.opt.visualization._process_monitor.pages import HomePage, WorkerPage, PredictionModelPage, OptunaVisualizerPage
-from pyfemtet._message import Msg
-
-
-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.get_df(valid_only=True)
-
-    @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.set_df(value)
-
-    def setup_callback(self, debug=False):
-        if not debug:
-            super().setup_callback()
-
-        from pyfemtet.opt._femopt_core import OptimizationStatus
-
-        @self.server.route('/interrupt')
-        def some_command():
-
-            # If the entire_state < INTERRUPTING, set INTERRUPTING
-            if self.local_entire_status_int < OptimizationStatus.INTERRUPTING:
-                self.local_entire_status_int = OptimizationStatus.INTERRUPTING
-                result = {"message": "Interrupting signal emitted successfully."}
-
-            else:
-                result = {"message": "Interrupting signal is already emitted."}
-
-            return jsonify(result)
-
-    def start_server(self, host=None, port=None, host_record=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,),
-            kwargs=dict(host_record=host_record),
-            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.get_df(valid_only=True).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)
-
-    @staticmethod
-    def get_status_color(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=False,
-    )
-
-    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_optuna, 2)
-    g_application.add_page(g_worker_page, 3)
-    g_application.setup_callback(debug=False)
-
-    g_application.run(debug=False)
-
-
-def main(history, status, worker_addresses, worker_status_list, host=None, port=None, host_record=None):
-    g_application = ProcessMonitorApplication(history, status, worker_addresses, worker_status_list)
-
-    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_optuna, 2)
-    g_application.add_page(g_worker_page, 3)
-    g_application.setup_callback()
-
-    g_application.start_server(host, port, host_record)
-
-
-if __name__ == '__main__':
-    g_debug()