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

pyfemtet/opt/visualization/plotter/pm_graph_creator.py

@@ -0,0 +1,359 @@
+import numpy as np
+import plotly.graph_objects as go
+
+from pyfemtet._i18n import _
+from pyfemtet._util.df_util import *
+from pyfemtet.opt.history import *
+from pyfemtet.opt.prediction._model import *
+from pyfemtet.opt.prediction._helper import *
+
+
+__all__ = [
+    'plot2d',
+    'plot3d',
+]
+
+
+def get_grid_values(history: History, df, prm_name_, n) -> np.ndarray:
+    if history._records.column_manager.is_numerical_parameter(prm_name_):
+        lb_, ub_ = get_bounds_containing_entire_bounds(df, prm_name_)
+        out = np.linspace(lb_, ub_, n)
+    elif history._records.column_manager.is_categorical_parameter(prm_name_):
+        choices = get_choices_containing_entire_bounds(df, prm_name_)
+        out = np.array(list(choices))
+    else:
+        raise NotImplementedError
+    return out
+
+
+def plot2d(
+        history: History,
+        prm_name1,
+        params: dict[str, float],
+        obj_name: str,
+        df,
+        pyfemtet_model: PyFemtetModel,
+        n=200,
+) -> go.Figure:
+    return _plot(
+        history=history,
+        prm_name1=prm_name1,
+        prm_name2=None,
+        params=params,
+        obj_name=obj_name,
+        df=df,
+        pyfemtet_model=pyfemtet_model,
+        n=n,
+    )
+
+
+def plot3d(
+        history: History,
+        prm_name1,
+        prm_name2,
+        params: dict[str, float],
+        obj_name: str,
+        df,
+        pyfemtet_model: PyFemtetModel,
+        n=20,
+) -> go.Figure:
+    return _plot(
+        history=history,
+        prm_name1=prm_name1,
+        prm_name2=prm_name2,
+        params=params,
+        obj_name=obj_name,
+        df=df,
+        pyfemtet_model=pyfemtet_model,
+        n=n,
+    )
+
+
+def _plot(
+        history: History,
+        prm_name1: str,
+        prm_name2: str | None,
+        params: dict[str, float],
+        obj_name: str,
+        df,
+        pyfemtet_model: PyFemtetModel,
+        n,
+) -> go.Figure:
+
+    is_3d = prm_name2 is not None
+
+    # prepare input
+    if is_3d:
+        prm_values1 = get_grid_values(history, df, prm_name1, n)
+        prm_values2 = get_grid_values(history, df, prm_name2, n)
+
+        # plot 用の格子点を作成
+        xx1, xx2 = np.meshgrid(prm_values1, prm_values2)
+
+        # predict 用のデータを作成
+        x1 = xx1.ravel()
+        x2 = xx2.ravel()
+    else:
+        prm_values1 = get_grid_values(history, df, prm_name1, n)
+        xx1 = prm_values1
+        x1 = xx1
+        prm_values2 = None
+        xx2 = None
+        x2 = None
+
+    # predict 用の入力を作成
+    x = np.empty((int(np.prod(xx1.shape)), len(history.prm_names))).astype(object)
+    for i, prm_name in enumerate(history.prm_names):
+        if prm_name == prm_name1:
+            x[:, i] = x1
+        elif prm_name == prm_name2:
+            assert x2 is not None, 'prm_name2 must be None.'
+            x[:, i] = x2
+        else:
+            x[:, i] = params[prm_name]
+
+    # predict
+    z_mean_, z_std_ = pyfemtet_model.predict(x)
+
+    # target objective を抽出
+    obj_idx = history.obj_names.index(obj_name)
+    z_mean, z_std = z_mean_[:, obj_idx], z_std_[:, obj_idx]
+
+    # 3d 用 grid に変換
+    if is_3d:
+        zz_mean, zz_std = z_mean.reshape(xx1.shape), z_std.reshape(xx1.shape)
+    else:
+        zz_mean, zz_std = None, None
+
+    # plot
+    fig = go.Figure()
+
+    # rsm
+    if is_3d:
+        assert prm_name2 is not None
+        assert prm_values2 is not None
+        assert xx2 is not None
+        assert zz_mean is not None
+        assert zz_std is not None
+
+        zz_upper = zz_mean + zz_std
+        zz_lower = zz_mean - zz_std
+
+        # std
+        fig.add_trace(go.Surface(
+            z=zz_upper, x=xx1, y=xx2,
+            showscale=False, opacity=0.3, showlegend=True,
+            name=_('Upper of pred. std-dev')))
+        fig.add_trace(go.Surface(
+            z=zz_lower, x=xx1, y=xx2,
+            showscale=False, opacity=0.3, showlegend=True,
+            name=_('Lower of pred. std-dev')))
+
+        # mean
+        contours = {}
+        for key, prm_name, prm_values in zip(('x', 'y'), (prm_name1, prm_name2), (prm_values1, prm_values2)):
+            if history._records.column_manager.is_numerical_parameter(prm_name):
+                lb, ub = prm_values.min(), prm_values.max()
+                contours.update({key: dict(
+                    highlight=True, show=True, color='blue',
+                    start=lb, end=ub, size=(ub - lb) / n,
+                )})
+            elif history._records.column_manager.is_categorical_parameter(prm_name):
+                contours.update({key: dict(
+                    highlight=True, show=True, color='blue',
+                )})
+        fig.add_trace(
+            go.Surface(
+                x=xx1, y=xx2, z=zz_mean,
+                name=_('Prediction'),
+                showlegend=True,
+                contours=contours,
+                colorbar=dict(
+                    x=0.2,
+                    xref="container",
+                ),
+            )
+        )
+    else:
+        # std
+        fig.add_trace(
+            go.Scatter(
+                x=list(x1) + list(x1)[::-1],
+                y=list(z_mean + z_std) + list(z_mean - z_std)[::-1],
+                name=_('Std-dev of pred.'),
+                fill='toself',
+                opacity=0.3,
+            )
+        )
+
+        # mean
+        fig.add_trace(
+            go.Scatter(
+                x=x1, y=z_mean,
+                name=_('Prediction'),
+            )
+        )
+
+    # scatter
+    sub_fidelity_names = history.sub_fidelity_names
+    obj_names_per_sub_fidelity_list: list[list[str]] = [
+        history.obj_names for __ in sub_fidelity_names
+    ]
+
+    if is_3d:
+
+        # main
+        df_main = get_partial_df(df, MAIN_FILTER)
+        fig.add_trace(go.Scatter3d(
+            x=df_main[prm_name1], y=df_main[prm_name2], z=df_main[obj_name],
+            mode='markers',
+            marker=dict(
+                size=3,
+                line=dict(
+                    width=1,
+                    color='white',
+                ),
+            ),
+            name='trial',
+        ))
+
+        # sub fidelity
+        for (
+                sub_fidelity_name,
+                obj_names_per_sub_fidelity,
+                # color
+        ) in zip(
+            sub_fidelity_names,
+            obj_names_per_sub_fidelity_list,
+            # px.colors.qualitative.G10[::-1]
+        ):
+
+            if sub_fidelity_name == MAIN_FILTER:
+                continue
+            df_sub = get_partial_df(df, equality_filters=dict(sub_fidelity_name=sub_fidelity_name))
+
+            fig.add_trace(go.Scatter3d(
+                x=df_sub[prm_name1], y=df_sub[prm_name2], z=df_sub[obj_name],
+                mode='markers',
+                marker=dict(
+                    size=3,
+                    line=dict(
+                        width=1,
+                        color='white',
+                    ),
+                    symbol='square-open',  # TODO: sequence 化
+                ),
+                name=f'trial of {sub_fidelity_name}',
+            ))
+
+    else:
+        # main
+        df_main = get_partial_df(df, MAIN_FILTER)
+        fig.add_trace(go.Scatter(
+            x=df_main[prm_name1], y=df_main[obj_name],
+            mode='markers',
+            marker=dict(
+                line=dict(
+                    width=1,
+                    color='white',
+                ),
+            ),
+            name='trial',
+        ))
+
+        # sub fidelity
+        for (
+                sub_fidelity_name,
+                obj_names_per_sub_fidelity,
+                # color
+        ) in zip(
+            sub_fidelity_names,
+            obj_names_per_sub_fidelity_list,
+            # px.colors.qualitative.G10[::-1]
+        ):
+
+            if sub_fidelity_name == MAIN_FILTER:
+                continue
+            df_sub = get_partial_df(df, equality_filters=dict(sub_fidelity_name=sub_fidelity_name))
+
+            fig.add_trace(go.Scatter(
+                x=df_sub[prm_name1], y=df_sub[obj_name],
+                mode='markers',
+                marker=dict(
+                    line=dict(
+                        width=1,
+                        color='white',
+                    ),
+                    symbol='square-open',  # TODO: sequence 化
+                ),
+                name=f'trial of {sub_fidelity_name}',
+            ))
+
+    # set opacity by its distance
+    params_ = params.copy()
+    params_.pop(prm_name1)
+    if is_3d:
+        params_.pop(prm_name2)
+    if len(params_) == 0:
+        opacity = np.ones(len(df))
+    else:
+        # distance を計算する用のデータを分割
+        prm_names_for_distances = []
+        prm_values_for_distances = []
+        prm_names_for_categorical = []
+        prm_values_for_categorical = []
+        for prm_name in params_.keys():
+            if history.is_numerical_parameter(prm_name):
+                prm_names_for_distances.append(prm_name)
+                prm_values_for_distances.append(params_[prm_name])
+            elif history.is_categorical_parameter(prm_name):
+                prm_names_for_categorical.append(prm_name)
+                prm_values_for_categorical.append(params_[prm_name])
+            else:
+                raise NotImplementedError
+
+        # distance が大きい程 opacity を小さくする
+        if len(prm_names_for_distances) > 0:
+            target_points = df[prm_names_for_distances]
+            hyper_plane = np.array(prm_values_for_distances)
+            distances_to_hyper_plane = np.linalg.norm(target_points - hyper_plane, axis=1, keepdims=False)
+            opacity = 1 - (distances_to_hyper_plane / distances_to_hyper_plane.max())
+        else:
+            opacity = np.ones(len(df))
+
+        # categorical データが一致しないぶんだけ opacity を 1/N する
+        target_points = df[prm_names_for_categorical].values
+        hyper_plane = np.array(prm_values_for_categorical)
+        # noinspection PyUnresolvedReferences
+        count = (target_points == hyper_plane).astype(float).sum(axis=1)
+        count = count + 1  # 0 になると困る
+        # noinspection PyUnusedLocal
+        opacity = opacity * (count / count.max())  # FIXME: 0 除算エラーが取り切れていない場合がある
+
+    def set_opacity(trace):
+        if isinstance(trace, go.Scatter3d) or isinstance(trace, go.Scatter):
+            trace.marker.color = [f'rgba(0, 0, 0, {o: .2f})' for o in opacity]
+
+    fig.for_each_trace(set_opacity)
+
+    # axis name
+    if is_3d:
+        # layout
+        fig.update_layout(
+            title=_('Prediction Model'),
+            xaxis_title=prm_name1,
+            yaxis_title=obj_name,
+        )
+
+    else:
+        fig.update_layout(
+            title=_('Prediction Model'),
+            scene=dict(
+                xaxis_title=prm_name1,
+                yaxis_title=prm_name2,
+                zaxis_title=obj_name
+            ),
+            margin=dict(l=0, r=0, b=0, t=30),
+        )
+
+    return fig

pyfemtet/opt/worker_status.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import math
+
+from pyfemtet._util.dask_util import *
+from pyfemtet.logger import get_module_logger
+
+__all__ = [
+    'WorkerStatus',
+    'ENTIRE_PROCESS_STATUS_KEY'
+]
+
+logger = get_module_logger('opt.worker_status', False)
+ENTIRE_PROCESS_STATUS_KEY = 'entire_process_status'
+
+
+class _WorkerStatus(float):
+
+    string: str
+
+    # noinspection PyUnusedLocal
+    def __init__(self, x, string):
+        self.string = string
+
+    def __new__(cls, __x=..., string=...):
+        return super().__new__(cls, __x)  # クラス変数インスタンス
+
+    def __repr__(self):
+        return self.string
+
+    def str(self):
+        return str(self)
+
+
+def worker_status_from_float(value: float):
+    if math.isnan(value):
+        return _WorkerStatus(value, 'Undefined')
+    elif value == float(0):
+        return _WorkerStatus(value, 'Initializing')
+    elif value == float(10):
+        return _WorkerStatus(value, 'Launching FEM')
+    elif value == float(20):
+        return _WorkerStatus(value, 'Waiting for other workers')
+    elif value == float(30):
+        return _WorkerStatus(value, 'Running')
+    elif value == float(40):
+        return _WorkerStatus(value, 'Interrupting')
+    elif value == float(45):
+        return _WorkerStatus(value, 'Finishing')
+    elif value == float(50):
+        return _WorkerStatus(value, 'Finished')
+    elif value == float(60):
+        return _WorkerStatus(value, 'Crashed')
+    elif value == float('inf'):
+        return _WorkerStatus(value, 'Terminated')
+    else:
+        raise NotImplementedError(f'worker_status_from_float: {value=}')
+
+
+class WorkerStatus:
+
+    undefined = worker_status_from_float(float('nan'))
+    initializing = worker_status_from_float(0)
+    launching_fem = worker_status_from_float(10)
+    waiting = worker_status_from_float(20)
+    running = worker_status_from_float(30)
+    interrupting = worker_status_from_float(40)
+    finishing = worker_status_from_float(45)
+    finished = worker_status_from_float(50)
+    crashed = worker_status_from_float(60)
+    terminated = worker_status_from_float(float('inf'))
+
+    def __init__(self, dataset_name: str):
+        self._dataset_name = dataset_name
+        self.__value: _WorkerStatus
+        self.value = WorkerStatus.undefined
+
+    @property
+    def value(self) -> _WorkerStatus:
+
+        out = None
+
+        client = get_client()
+        if client is not None:
+            if client.scheduler is not None:
+                key = self._dataset_name
+                value: float | None = client.get_metadata(key, default=None)
+
+                # value は単なる float になるので型変換
+                if isinstance(value, float):
+                    value: _WorkerStatus = worker_status_from_float(value)
+
+                # setter の時点では client がなかった場合など
+                elif value is None:
+                    value = self.__value
+                    client.set_metadata(key, value)
+
+                out = value
+
+            # client はあるが、close された後である場合
+            else:
+                self.__value = WorkerStatus.terminated
+                out = self.__value
+        else:
+            out = self.__value
+
+        assert out is not None
+
+        self.__value = out
+        return out
+
+    @value.setter
+    def value(self, value: _WorkerStatus):
+        client = get_client()
+        if client is not None:
+            if client.scheduler is not None:
+                key = self._dataset_name
+                client.set_metadata(key, value)
+                # sleep(0.1)
+        self.__value = value

{pyfemtet-0.9.5.dist-info → pyfemtet-1.0.0b0.dist-info}/METADATA

@@ -1,40 +1,39 @@
 Metadata-Version: 2.3
 Name: pyfemtet
-Version: 0.9.5
+Version: 1.0.0b0
 Summary: Design parameter optimization using Femtet.
 License: MIT
 Author: kazuma.naito
 Author-email: 148934231+pyfemtet@users.noreply.github.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >= 3.10, < 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: brep
-Requires-Dist: babel (>=2.15.0,<3.0.0)
-Requires-Dist: botorch (>=0.12.0,<0.13.0)
-Requires-Dist: brepmatching (>=0.1.8,<0.2.0) ; extra == "brep"
-Requires-Dist: colorlog (>=6.8.0,<7.0.0)
-Requires-Dist: dash (>=2.17.0,<3.0.0)
-Requires-Dist: dash-bootstrap-components (>=1.5.0,<2.0.0)
-Requires-Dist: dask (>=2023.12.1,<2024.0.0)
-Requires-Dist: distributed (>=2023.12.1,<2024.0.0)
-Requires-Dist: femtetutils (>=1.0.0,<2.0.0) ; sys_platform == "win32"
-Requires-Dist: fire (>=0.6.0,<0.7.0)
-Requires-Dist: numpy (>=2.0.0,<3.0.0)
-Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: babel (>=2.15.0,<3)
+Requires-Dist: botorch (>=0.12.0,<0.15.0)
+Requires-Dist: colorlog (>=6.8.0,<7)
+Requires-Dist: dash (>=2.17.0,<3)
+Requires-Dist: dash-bootstrap-components (>=1.5.0,<2)
+Requires-Dist: dask (>=2024.12.1,<2024.13.0)
+Requires-Dist: distributed (>=2024.12.1,<2024.13.0)
+Requires-Dist: femtetutils (>=1.0.0,<2) ; sys_platform == "win32"
+Requires-Dist: fire (>=0.7)
+Requires-Dist: numpy (>=2.0.0,<3)
+Requires-Dist: openpyxl (>=3.1.2,<4)
 Requires-Dist: optuna (>=3.4.0,<5.0.0)
 Requires-Dist: optuna-integration (>=3.6.0,<5.0.0)
-Requires-Dist: pandas (>=2.2.3,<3.0.0)
-Requires-Dist: plotly (>=5.22.0,<6.0.0)
-Requires-Dist: psutil (>=5.9.6,<6.0.0)
-Requires-Dist: pywin32 (>=306,<307) ; sys_platform == "win32"
-Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
-Requires-Dist: scipy (>=1.11.4,<2.0.0)
-Requires-Dist: torch (>=2.5.1,<2.6.0) ; sys_platform != "linux"
-Requires-Dist: torch (>=2.5.1,<2.6.0) ; sys_platform == "linux"
-Requires-Dist: tqdm (>=4.66.1,<5.0.0)
+Requires-Dist: pandas (>=2.2.3,<3)
+Requires-Dist: plotly (>=5.22.0,<6)
+Requires-Dist: psutil (>=5.9.6,<6)
+Requires-Dist: pywin32 (<307) ; sys_platform == "win32" and python_version < "3.13"
+Requires-Dist: pywin32 (>=309) ; sys_platform == "win32" and python_version >= "3.13"
+Requires-Dist: pyyaml (>=6.0.2,<7)
+Requires-Dist: scipy (>=1.11.4,<2)
+Requires-Dist: torch
+Requires-Dist: tqdm (>=4.66.1,<5)
 Project-URL: Repository, https://github.com/pyfemtet/pyfemtet
 Description-Content-Type: text/markdown