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

pyfemtet/opt/problem/variable_manager/_string_as_expression.py

@@ -0,0 +1,115 @@
+from numbers import Number
+
+from sympy import sympify
+from sympy.core.sympify import SympifyError
+from sympy import Min, Max, Add, Symbol, Expr, Basic  # TODO: Add sqrt, pow
+
+__all__ = [
+    '_ExpressionFromString', 'InvalidExpression', 'SympifyError'
+]
+
+
+class InvalidExpression(Exception):
+    pass
+
+
+def get_valid_functions(values_may_be_used_in_mean: dict[str, Number] = None):
+    v = values_may_be_used_in_mean or {}
+    return {
+        'mean': lambda *args: Add(*args).subs(v) / len(args),
+        'max': Max,
+        'min': Min,
+        'S': Symbol('S')
+    }
+
+
+class _ExpressionFromString:
+    _expr_str: str
+    _sympy_expr: Expr
+
+    def __init__(self, expression_string: str | Number = None, sympy_expr: Expr = None):
+        """
+        Raises:
+            SympifyError: Sympy が認識できない場合
+            InvalidExpression: Sympy は認識できるが PyFemtet で想定する型ではない場合（tuple など）
+
+        Examples:
+            e = Expression('1')
+            e.expr  # '1'
+            e.value  # 1.0
+
+            e = Expression(1)
+            e.expr  # '1'
+            e.value  # 1.0
+
+            e = Expression('a')
+            e.expr  # 'a'
+            e.value  # ValueError
+
+            e = Expression('1/2')
+            e.expr  # '1/2'
+            e.value  # 0.5
+
+            e = Expression('1.0000')
+            e.expr  # '1.0'
+            e.value  # 1.0
+
+        """
+
+        # check
+        assert not (expression_string is None and sympy_expr is None)
+
+        if sympy_expr is not None:
+            assert expression_string is None
+            self._sympy_expr = sympy_expr
+            self._expr_str = str(sympy_expr)
+
+        else:
+            assert expression_string is not None
+            self._expr_str: str = str(expression_string)
+
+            # max(name1, name2) など関数を入れる際に問題になるので
+            # 下記の仕様は廃止、使い方として数値桁区切り , を入れてはいけない
+            # # sympify 時に tuple 扱いになるので , を置き換える
+            # # 日本人が数値に , を使うとき Python では _ を意味する
+            # # expression に _ が入っていても構わない
+            # tmp_expr = str(self._expr_str).replace(',', '_')
+            self._sympy_expr = sympify(self._expr_str, locals=get_valid_functions())
+
+        if not isinstance(self._sympy_expr, Basic):
+            raise InvalidExpression(f'{self._expr_str} は数式ではありません。')
+
+    @property
+    def dependency(self) -> set[str]:
+        s: Symbol
+        return {s.name for s in self._sympy_expr.free_symbols}
+
+    def is_number(self) -> bool:
+        return self._sympy_expr.is_number
+
+    def is_expression(self) -> bool:
+        return not self.is_number()
+
+    @property
+    def expression_string(self) -> str:
+        return self._expr_str
+
+    def eval(self, dependency_values: dict[str, Number]):
+
+        # 型チェック
+        assert all([isinstance(value, Number) for value
+                    in dependency_values.values()]), \
+            'ExpressionFromString では数値変数のみをサポートしています。'
+
+        re_sympy_expr = sympify(
+            self.expression_string,
+            locals=get_valid_functions(dependency_values),
+        )
+
+        evaluated_sympy_obj = re_sympy_expr.subs(dependency_values)
+        try:
+            evaluated_value = float(evaluated_sympy_obj)
+        except (ValueError, TypeError) as e:
+            raise type(e)(*e.args, f'{evaluated_sympy_obj=} cannot convert to float.') from None
+
+        return evaluated_value

pyfemtet/opt/problem/variable_manager/_variable_manager.py

@@ -0,0 +1,295 @@
+from typing import Callable, TypeAlias, Literal
+
+import inspect
+from numbers import Real  # マイナーなので型ヒントには使わず isinstance で使う
+from graphlib import TopologicalSorter
+
+import numpy as np
+
+from ._string_as_expression import _ExpressionFromString
+
+from pyfemtet._i18n import _
+
+__all__ = [
+    'SupportedVariableTypes',
+    'Parameter',
+    'Variable',
+    'NumericVariable',
+    'NumericParameter',
+    'CategoricalVariable',
+    'CategoricalParameter',
+    'Expression',
+    'ExpressionFromFunction',
+    # 'NumericExpressionFromFunction',
+    # 'CategoricalExpressionFromFunction',
+    'ExpressionFromString',
+    'VariableManager',
+]
+
+
+SupportedVariableTypes: TypeAlias = str | Real  # isinstance で使いうるので Real
+
+
+class Variable:
+    name: str
+    value: SupportedVariableTypes
+    pass_to_fem: bool
+    properties: dict[str, ...]
+
+    def __init__(self):
+        # noinspection PyTypeChecker
+        self.value = None
+        self.properties = {}
+
+    def __repr__(self):
+        return str(self.value)
+
+
+class Parameter(Variable):
+    pass
+
+
+class NumericVariable(Variable):
+    value: float
+
+
+class NumericParameter(NumericVariable, Parameter):
+    value: float
+    lower_bound: float | None
+    upper_bound: float | None
+    step: float | None
+
+
+class CategoricalVariable(Variable):
+    value: str
+
+
+class CategoricalParameter(CategoricalVariable, Parameter):
+    choices: list[str]
+
+
+class Expression(Variable):
+    pass
+
+
+class ExpressionFromFunction(Expression):
+    fun: Callable
+    args: tuple | None
+    kwargs: dict | None
+
+
+class NumericExpressionFromFunction(ExpressionFromFunction, NumericVariable):
+    fun: Callable[..., float]
+
+
+class CategoricalExpressionFromFunction(ExpressionFromFunction, CategoricalVariable):
+    fun: Callable[..., str]
+
+
+class ExpressionFromString(Expression, NumericVariable):
+    _expr: _ExpressionFromString
+    InternalClass: type = _ExpressionFromString
+
+
+class VariableManager:
+
+    variables: dict[str, Variable]
+    dependencies: dict[str, set[str]]
+    evaluation_order: list[str]  # 評価する順番
+
+    def __init__(self):
+        super().__init__()
+        self.variables = dict()
+        self.dependencies = dict()
+
+    @staticmethod
+    def _calc_dependencies(variables: dict[str, Variable]) -> dict[str, set[str]]:
+
+        dependencies: dict[str, set[str]] = dict()
+        all_var_names: set[str] = set(variables.keys())
+
+        var_name: str
+        for var_name, var in variables.items():
+
+            # Expression ならば、fun の引数のうち
+            # variables の名前であるものを dependency とする
+            if isinstance(var, ExpressionFromFunction):
+                arg_names: set[str] = set(inspect.signature(var.fun).parameters)
+                dep_var_names: set[str] = all_var_names & arg_names
+                dependency = dep_var_names
+
+            # ExpressionString であれば、
+            # 使われている変数を解析する
+            elif isinstance(var, ExpressionFromString):
+                dependency = var._expr.dependency
+
+            else:
+                assert isinstance(var, Variable)
+                dependency = {}
+
+            dependencies.update({var_name: dependency})
+
+        return dependencies
+
+    @staticmethod
+    def _calc_evaluation_order(dependencies: dict[str, set[str]]) -> list[str]:
+        ts = TopologicalSorter(dependencies)
+        return list(ts.static_order())
+
+    def resolve(self):
+        self.dependencies = self._calc_dependencies(self.variables)
+        self.evaluation_order = self._calc_evaluation_order(self.dependencies)
+
+    def eval_expressions(self):
+
+        for var_name in self.evaluation_order:
+
+            var = self.variables[var_name]
+
+            # fun を持つ場合
+            if isinstance(var, ExpressionFromFunction):
+
+                # pop するので list をコピーしておく
+                user_def_args = list(var.args)
+
+                # 位置引数を揃え、残りをキーワード引数にする
+                pos_args = []
+                kw_args = var.kwargs or {}
+
+                # 引数順に調べる
+                required_arg_names = inspect.signature(var.fun).parameters.values()
+                for p in required_arg_names:
+
+                    # 位置引数であ（りう）る
+                    if p.kind <= inspect.Parameter.POSITIONAL_OR_KEYWORD:
+
+                        # 変数である
+                        if p.name in self.variables:
+                            # order 順に見ているのですでに value が正しいはず
+                            pos_args.append(self.variables[p.name].value)
+
+                        # ユーザー定義位置引数である
+                        else:
+                            try:
+                                pos_args.append(user_def_args.pop(0))
+                            except IndexError as e:  # pop from empty list
+                                msg = []
+                                for p_ in required_arg_names:
+                                    if p_.kind == inspect.Parameter.VAR_POSITIONAL:
+                                        msg.append(f'*{p_.name}')
+                                    elif p_.kind == inspect.Parameter.VAR_KEYWORD:
+                                        msg.append(f'**{p_.name}')
+                                    else:
+                                        msg.append(p_.name)
+                                raise type(e)(
+                                    *e.args,
+                                    _(
+                                        'Missing arguments! '
+                                        'The arguments specified by `args`: {var_args} / '
+                                        'The arguments specified by `kwargs`: {var_kwargs} / '
+                                        'Required arguments: {msg}',
+                                        var_args=var.args,
+                                        var_kwargs=var.kwargs,
+                                        msg=msg
+                                    ),
+                                ) from None
+
+                    # *args である
+                    elif p.kind == inspect.Parameter.VAR_POSITIONAL:
+
+                        # ユーザー定義位置引数でないとおかしい
+                        assert p.name not in self.variables, _('Extra positional argument name cannot be duplicated with a variable name.')
+
+                        # *args なので残り全部を pos_args に入れる
+                        pos_args.extend(user_def_args)
+
+                    # キーワード引数である
+                    elif p.kind == inspect.Parameter.KEYWORD_ONLY:
+
+                        # 変数である
+                        if p.name in self.variables:
+                            # order 順に見ているのですでに value が正しいはず
+                            kw_args.update({p.name: self.variables[p.name].value})
+
+                    # **kwargs である
+                    else:
+
+                        # kw_args にユーザー定義キーワード引数を入れているので何もしなくてよい
+                        assert p.name not in self.variables, _('Extra keyword argument name cannot be duplicated with a variable name.')
+
+                # fun を実行する
+                var.value = var.fun(*pos_args, **kw_args)
+
+            # string expression の場合
+            elif isinstance(var, ExpressionFromString):
+
+                # dependency_values を作る
+                dependency: set[str] = var._expr.dependency
+
+                # order 順に見ているので value は正しいはず
+                dependency_values: dict[str, SupportedVariableTypes] = {
+                    dep_name: self.variables[dep_name].value
+                    for dep_name in dependency
+                }
+
+                # 計算
+                var.value = var._expr.eval(dependency_values)
+
+            # その他 = Expression ではない場合
+            else:
+                # optimizer によって直接 update されている
+                # はずなので何もしなくてよい
+                pass
+
+    # noinspection PyShadowingBuiltins
+    def get_variables(
+            self,
+            *,
+            filter: (Literal['pass_to_fem', 'parameter']
+                     | tuple[Literal['pass_to_fem', 'parameter']]
+                     | None) = None,  # 'pass_to_fem' and 'parameter' (OR filter)
+            format: str = None,  # None, 'dict' and 'values'
+    ) -> (
+        dict[str, Variable]
+        | dict[str, Parameter]
+        | dict[str, SupportedVariableTypes]
+        | np.ndarray
+    ):
+
+        raw = {}
+
+        for name, var in self.variables.items():
+
+            if filter is not None:
+                if 'pass_to_fem' in filter:
+                    if var.pass_to_fem:
+                        raw.update({name: var})
+
+                if 'parameter' in filter:
+                    if isinstance(var, Parameter):
+                        raw.update({name: var})
+
+            else:
+                raw.update({name: var})
+
+        if format is None:
+            return raw
+
+        elif format == 'raw':
+            return raw
+
+        elif format == 'dict':
+            return {name: var.value for name, var in raw.items()}
+
+        elif format == 'values':
+            return np.array([var.value for var in raw.values()])
+
+        else:
+            raise NotImplementedError(
+                _(
+                    'invalid format {format} is passed to '
+                    'VariableManager.get_variables(). '
+                    'Valid formats are one of (`raw`, `dict`, `values`).',
+                    format=format,
+                )
+            )

pyfemtet/opt/visualization/history_viewer/__main__.py

@@ -0,0 +1,5 @@
+from pyfemtet.opt.visualization.history_viewer.result_viewer._application import result_viewer_main
+
+
+if __name__ == '__main__':
+    result_viewer_main()

pyfemtet/opt/visualization/{_base.py → history_viewer/_base_application.py}

@@ -14,24 +14,32 @@ from dash import Output, Input  # , State, no_update, callback_context
 # from dash import html, dcc
 import dash_bootstrap_components
 
-from pyfemtet.opt._femopt_core import History
-from pyfemtet.opt.visualization._wrapped_components import html, dcc, dbc
+# from pyfemtet.opt._femopt_core import History
+# from pyfemtet.opt.visualization._wrapped_components import html, dcc, dbc
+from pyfemtet.opt.history import History
+from pyfemtet.opt.visualization.history_viewer._wrapped_components import html
+from pyfemtet.opt.visualization.history_viewer._wrapped_components import dcc, dbc
 
 # the others
 from abc import ABC, abstractmethod
 import logging
 import psutil
-import json
 from pyfemtet.logger import get_module_logger, get_dash_logger
 
-logger = get_module_logger('opt.monitor', __name__)
+__all__ = [
+    'logger',
+    'AbstractPage',
+    'PyFemtetApplicationBase',
+]
+
+
+logger = get_module_logger('opt.monitor', False)
 logger.setLevel(logging.ERROR)
 
 dash_logger = get_dash_logger()
 dash_logger.setLevel(logging.ERROR)
 
 
-
 class AbstractPage(ABC):
     """Define content."""
     """
@@ -50,7 +58,7 @@ title -->home| |      | |
 
     """
     def __init__(self, title='base-page', rel_url='/', application=None):
-        self.layout: Component = None
+        self.layout: Component = html.Div('This is a abstract page before setup.')
         self.rel_url = rel_url
         self.title = title
         self.application: PyFemtetApplicationBase = application
@@ -135,6 +143,7 @@ class SidebarApplicationBase:
         self.title = title if title is not None else 'App'
         self.subtitle = subtitle if title is not None else ''
         self.server = Flask(__name__)
+        # noinspection PyTypeChecker
         self.app = Dash(
             __name__,
             external_stylesheets=[dash_bootstrap_components.themes.BOOTSTRAP],
@@ -239,15 +248,11 @@ class PyFemtetApplicationBase(SidebarApplicationBase):
             history: History = None,
     ):
         # register arguments
-        self.history = history  # include actor
+        self.history: History = history  # include actor
         super().__init__(title, subtitle)
 
-
-def check_page_layout(page_cls: type):
-    home_page = page_cls()  # required
-    application = PyFemtetApplicationBase(title='test-app')
-    application.add_page(home_page, 0)
-    application.run(debug=True)
+    def get_df(self, equality_filters: dict = None):
+        return self.history.get_df(equality_filters=equality_filters)
 
 
 if __name__ == '__main__':

pyfemtet/opt/visualization/history_viewer/_common_pages.py

@@ -0,0 +1,150 @@
+import optuna
+
+from dash import Output, Input
+
+from pyfemtet.opt.visualization.history_viewer._wrapped_components import html
+from pyfemtet.opt.visualization.history_viewer._wrapped_components import dcc
+from pyfemtet.opt.visualization.history_viewer._base_application import AbstractPage
+from pyfemtet.opt.visualization.history_viewer._complex_components.pm_graph import *
+
+from pyfemtet._i18n import Msg
+
+__all__ = [
+    'PredictionModelPage',
+    'OptunaVisualizerPage',
+]
+
+
+DBC_COLUMN_STYLE_CENTER = {
+    'display': 'flex',
+    'justify-content': 'center',
+    'align-items': 'center',
+}
+
+DBC_COLUMN_STYLE_RIGHT = {
+    'display': 'flex',
+    'justify-content': 'right',
+    'align-items': 'right',
+}
+
+
+def is_iterable(component):
+    return hasattr(component, '__len__')
+
+
+class PredictionModelPage(AbstractPage):
+    rsm_graph: PredictionModelGraph
+
+    def __init__(self, title, rel_url, application):
+        super().__init__(title, rel_url, application)
+
+    def setup_component(self):
+        self.rsm_graph: PredictionModelGraph = PredictionModelGraph()
+        self.add_subpage(self.rsm_graph)
+
+    def setup_layout(self):
+        self.layout = self.rsm_graph.layout
+
+
+class OptunaVisualizerPage(AbstractPage):
+    location: dcc.Location
+    _layout: html.Div
+
+    def __init__(self, title, rel_url, application):
+        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_for_visualization()
+        # prm_names = self.application.history.prm_names
+        obj_names = self.application.history.obj_names
+
+        layout = list()
+
+        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'}))
+
+        layout.append(html.H2(Msg.DETAIL_PAGE_IMPORTANCE_HEADER))
+        layout.append(html.H4(Msg.DETAIL_PAGE_IMPORTANCE_DESCRIPTION))
+        for i, obj_name in enumerate(obj_names):
+            fig = optuna.visualization.plot_param_importances(
+                study,
+                target=lambda t: t.values[i],
+                target_name=obj_name
+            )
+            import plotly.graph_objects as go
+            fig: go.Figure
+            fig.update_layout(title=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.application.get_df()) == 0:
+                return Msg.ERR_NO_FEM_RESULT
+
+            return self._setup_layout()
+
+    def setup_layout(self):
+        pass

pyfemtet/opt/visualization/{_complex_components → history_viewer/_complex_components}/alert_region.py

@@ -3,13 +3,17 @@ from typing import List
 from dash.development.base_component import Component
 
 # callback
-from dash import Output, Input, State, no_update, callback_context
-from dash.exceptions import PreventUpdate
+from dash import Output, Input
 
 # components
-from pyfemtet.opt.visualization._wrapped_components import html, dcc, dbc
+from pyfemtet.opt.visualization.history_viewer._wrapped_components import dbc
 
-from pyfemtet.opt.visualization._base import AbstractPage, logger
+from pyfemtet.opt.visualization.history_viewer._base_application import AbstractPage
+
+
+__all__ = [
+    'AlertRegion'
+]
 
 
 class AlertRegion(AbstractPage):
@@ -53,7 +57,8 @@ class AlertRegion(AbstractPage):
         def clear_alerts(_):
             return []
 
-    def create_alerts(self, msg, color='secondary', current_alerts=None) -> List[Component]:
+    @staticmethod
+    def create_alerts(msg, color='secondary', current_alerts=None) -> List[Component]:
 
         if current_alerts is None:
             current_alerts = []