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

pyfemtet/opt/prediction/_helper.py

@@ -0,0 +1,155 @@
+import numpy as np
+import pandas as pd
+
+from optuna.distributions import (
+    FloatDistribution,
+    CategoricalDistribution,
+    BaseDistribution,
+    CategoricalChoiceType
+)
+from optuna._transform import _SearchSpaceTransform
+
+from pyfemtet.opt.history import *
+
+__all__ = [
+    'get_bounds_containing_entire_bounds',
+    'get_choices_containing_entire_bounds',
+    'get_params_list',
+    'get_params_list_from_ndarray',
+    'get_search_space',
+    'get_transform_0_1',
+    'get_transformed_params',
+]
+
+
+def get_bounds_containing_entire_bounds(df: pd.DataFrame, prm_name) -> tuple[float, float]:
+    """Get param bounds with all bounds"""
+
+    lb_name = CorrespondingColumnNameRuler.prm_lower_bound_name(prm_name)
+    lb = df[lb_name].dropna().min()
+
+    ub_name = CorrespondingColumnNameRuler.prm_upper_bound_name(prm_name)
+    ub = df[ub_name].dropna().max()
+
+    return float(lb), float(ub)
+
+
+def get_choices_containing_entire_bounds(df: pd.DataFrame, prm_name) -> set[CategoricalChoiceType]:
+    """Get param bounds with all choices"""
+
+    choices_name = CorrespondingColumnNameRuler.prm_choices_name(prm_name)
+    choices_values = df[choices_name].values
+    choices = set()
+    for choices_ in choices_values:
+        for c in choices_:
+            choices.add(c)
+    return choices
+
+
+def get_params_list(df: pd.DataFrame, history: History) -> list[dict[str, ...]]:
+    # get search space and parameters
+    params_list: list[dict[str, ...]] = []
+
+    # update params_list
+    for i, row in df.iterrows():
+
+        # create search space and parameter values
+        params = dict()
+
+        # inspect each parameter
+        for prm_name in history.prm_names:
+
+            # parameter value
+            params.update({prm_name: row[prm_name]})
+
+        # append params_list
+        params_list.append(params)
+
+    return params_list
+
+
+def get_params_list_from_ndarray(x: np.ndarray, history: History) -> list[dict[str, ...]]:
+    # get search space and parameters
+    params_list: list[dict[str, ...]] = []
+
+    # update params_list
+    for prm_values in x:
+
+        # create search space and parameter values
+        params = dict()
+
+        # parameter value
+        params.update(
+            {name: value for name, value
+             in zip(history.prm_names, prm_values)}
+        )
+
+        # append params_list
+        params_list.append(params)
+
+    return params_list
+
+
+def get_search_space(df: pd.DataFrame, history: History) -> dict[str, BaseDistribution]:
+    # get search_space
+    search_space = dict()
+    for prm_name in history.prm_names:
+        if history._records.column_manager.is_numerical_parameter(prm_name):
+            lb, ub = get_bounds_containing_entire_bounds(df, prm_name)
+            search_space.update({
+                prm_name: FloatDistribution(
+                    low=lb, high=ub,
+                )
+            })
+        elif history._records.column_manager.is_categorical_parameter(prm_name):
+            choices: set = get_choices_containing_entire_bounds(df, prm_name)
+            search_space.update({
+                prm_name: CategoricalDistribution(
+                    choices=tuple(choices)
+                )
+            })
+        else:
+            raise NotImplementedError
+    return search_space
+
+
+def get_transform_0_1(df: pd.DataFrame, history: History) -> _SearchSpaceTransform:
+    # get search_space
+    search_space = get_search_space(df, history)
+
+    # get transform
+    trans = _SearchSpaceTransform(search_space, transform_0_1=True)
+
+    return trans
+
+
+def get_transformed_params(
+        df_or_x: pd.DataFrame | np.ndarray, history: History, trans: _SearchSpaceTransform
+) -> np.ndarray:
+
+    out = np.empty(
+        (
+            0,
+            len(trans.encoded_column_to_column)  # ここ。choices ぶん増やす
+        ),
+        dtype=float
+    )
+
+    # get list of params
+    if isinstance(df_or_x, pd.DataFrame):
+        params_list = get_params_list(df_or_x, history)
+    elif isinstance(df_or_x, np.ndarray):
+        params_list = get_params_list_from_ndarray(df_or_x, history)
+    else:
+        raise NotImplementedError
+
+    # calc transformed value
+    for params in params_list:
+        trans_prm_values: np.ndarray = trans.transform(params)
+        out = np.concatenate(
+            [out, [trans_prm_values]],
+            dtype=float,
+            axis=0,
+        )
+
+    return out

pyfemtet/opt/prediction/_model.py

@@ -0,0 +1,118 @@
+import numpy as np
+import pandas as pd
+
+from optuna._transform import _SearchSpaceTransform
+import torch
+from botorch.models import SingleTaskGP
+
+from pyfemtet.opt.history import *
+from pyfemtet.opt.prediction._helper import *
+from pyfemtet.opt.prediction._botorch_utils import *
+from pyfemtet.opt.prediction._gpytorch_modules_extension import get_covar_module_with_dim_scaled_prior_extension
+
+
+__all__ = [
+    'PyFemtetModel',
+    'AbstractModel',
+    'SingleTaskGPModel',
+]
+
+
+class AbstractModel:
+
+    def fit(self, x: np.ndarray, y: np.ndarray, bounds: np.ndarray = None, **kwargs): ...
+    def predict(self, x: np.ndarray) -> tuple[np.ndarray, np.ndarray]: ...
+
+
+class SingleTaskGPModel(AbstractModel):
+
+    KWARGS = dict(dtype=torch.float64, device='cpu')
+    gp: SingleTaskGP
+
+    def fit(
+            self,
+            x: np.ndarray,
+            y: np.ndarray,
+            bounds: np.ndarray = None,
+            observation_noise=None,
+            likelihood_class=None,
+            covar_module_settings: dict = None,
+    ):
+
+        covar_module = None
+
+        X = torch.tensor(x, **self.KWARGS)
+        Y = torch.tensor(y, **self.KWARGS)
+        B = torch.tensor(bounds, **self.KWARGS).transpose(1, 0) if bounds is not None else None
+
+        if covar_module_settings is not None:
+            if covar_module_settings['name'] == 'matern_kernel_with_gamma_prior':
+                covar_module_settings.pop('name')
+                covar_module = get_matern_kernel_with_gamma_prior_as_covar_module(
+                    X, Y,
+                    **covar_module_settings,
+                )
+            elif covar_module_settings['name'] == 'get_covar_module_with_dim_scaled_prior_extension':
+                covar_module_settings.pop('name')
+
+                _input_batch_shape, _aug_batch_shape = SingleTaskGP.get_batch_dimensions(X, Y)
+                batch_shape = _aug_batch_shape
+
+                covar_module = get_covar_module_with_dim_scaled_prior_extension(
+                    ard_num_dims=X.shape[-1],
+                    batch_shape=batch_shape,
+                    **covar_module_settings,
+                )
+            else:
+                raise NotImplementedError(f'{covar_module_settings["name"]=}')
+
+        self.gp = setup_gp(X, Y, B, observation_noise, likelihood_class, covar_module)
+
+    def predict(self, x: np.ndarray):
+        assert hasattr(self, 'gp')
+        X = torch.tensor(x, **self.KWARGS)
+        post = self.gp.posterior(X)
+        with torch.no_grad():
+            mean = post.mean.numpy()
+            std = post.variance.sqrt().numpy()
+        return mean, std
+
+
+class PyFemtetModel:
+
+    current_trans: _SearchSpaceTransform
+    current_model: AbstractModel
+    history: History
+
+    def update_model(self, model: AbstractModel):
+        self.current_model = model
+
+    def fit(self, history: History, df: pd.DataFrame, **kwargs):
+        assert hasattr(self, 'current_model')
+        assert 'x' not in kwargs
+        assert 'y' not in kwargs
+        assert 'bounds' not in kwargs
+
+        self.history = history
+
+        # remove nan from df
+        df = df.dropna(subset=history.obj_names + history.prm_names, how='any')
+
+        # set current trans
+        self.current_trans = get_transform_0_1(df, history)
+
+        # transform all values
+        transformed_x = get_transformed_params(df, history, self.current_trans)
+
+        # bounds as setup maximum range
+        bounds = self.current_trans.bounds
+
+        y = df[history.obj_names].values
+        self.current_model.fit(transformed_x, y, bounds, **kwargs)
+
+    def predict(self, x: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        assert hasattr(self, 'history')
+        assert hasattr(self, 'current_trans')
+
+        transformed_x = get_transformed_params(x, self.history, self.current_trans)
+        return self.current_model.predict(transformed_x)

pyfemtet/opt/problem/problem.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+from typing import Callable, TYPE_CHECKING, TypeAlias, Sequence
+
+try:
+    # noinspection PyUnresolvedReferences
+    from pythoncom import CoInitialize, CoUninitialize
+    from win32com.client import Dispatch, Constants, constants
+except ModuleNotFoundError:
+    # noinspection PyPep8Naming
+    def CoInitialize(): ...
+    # noinspection PyPep8Naming
+    def CoUninitialize(): ...
+    Dispatch = type('NoDispatch', (object,), {})
+    Constants = type('NoConstants', (object,), {})
+    constants = Constants()
+
+from pyfemtet._i18n import _
+from pyfemtet._util.helper import *
+
+from .variable_manager import *
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+    from pyfemtet.opt.interface import AbstractFEMInterface
+
+__all__ = [
+    'TrialInput',
+    'TrialOutput',
+    'TrialConstraintOutput',
+    'Function',
+    'Functions',
+    'Objective',
+    'ObjectiveResult',
+    'Objectives',
+    'ObjectivesFunc',
+    'Constraint',
+    'ConstraintResult',
+    'Constraints',
+    'Fidelity',
+    'SubSampling',
+    'MAIN_FIDELITY_NAME',
+]
+
+MAIN_FIDELITY_NAME = ''
+
+
+class Function:
+    _fun: Callable[..., float]
+    args: tuple
+    kwargs: dict
+
+    @property
+    def fun(self) -> Callable[..., float]:
+        self._ScapeGoat.restore_constants(self._fun)
+        return self._fun
+
+    @fun.setter
+    def fun(self, f: Callable[..., float]):
+        self._fun = f
+
+    def __getstate__(self):
+        """Pickle 時に _fun が参照する constants を _ScapeGoat にする"""
+        state = self.__dict__
+        if '_fun' in state:
+            self._ScapeGoat.remove_constants(state['_fun'])
+        return state
+
+    def __setstate__(self, state):
+        """Pickle 時に _fun が参照する _ScapeGoat を constants にする"""
+        CoInitialize()
+        if '_fun' in state:
+            self._ScapeGoat.restore_constants(state['_fun'])
+        self.__dict__.update(state)
+
+    class _ScapeGoat:
+
+        @classmethod
+        def restore_constants(cls, f: ...):
+            """f の存在する global スコープの _Scapegoat 変数を constants に変更"""
+            if not hasattr(f, '__globals__'):
+                return
+
+            for name, var in f.__globals__.items():
+                if isinstance(var, cls):
+                    # try 不要
+                    # fun の定義がこのファイル上にある場合、つまりデバッグ時のみ
+                    # remove_constants がこのスコープの constants を消すので
+                    # constants を再インポートする必要がある
+                    from win32com.client import constants
+                    f.__globals__[name] = constants
+
+        @classmethod
+        def remove_constants(cls, f: ...):
+            """f の存在する global スコープの Constants 変数を _Scapegoat に変更"""
+
+            if not hasattr(f, '__globals__'):
+                return
+
+            for name, var in f.__globals__.items():
+                if isinstance(var, Constants):
+                    f.__globals__[name] = cls()
+
+    def eval(self, fem: AbstractFEMInterface) -> float:
+        return float(self.fun(fem.object_pass_to_fun, *self.args, **self.kwargs))
+
+
+class Functions(dict[str, Function]):
+    pass
+
+
+class Objective(Function):
+    direction: str | float
+
+    @staticmethod
+    def _convert(value, direction) -> float:
+
+        direction: float | str | None = float_(direction)
+
+        if value is None or direction is None:
+            value_as_minimize = float('nan')
+
+        elif isinstance(direction, str):
+            if direction.lower() == 'minimize':
+                value_as_minimize = value
+            elif direction.lower() == 'maximize':
+                value_as_minimize = -value
+            else:
+                raise NotImplementedError
+
+        else:
+            # if value is nan, return nan
+            value_as_minimize = (value - direction) ** 2
+
+        return value_as_minimize
+
+    def convert(self, value) -> float:
+        return self._convert(value, self.direction)
+
+
+class ObjectiveResult:
+
+    def __init__(self, obj: Objective, fem: AbstractFEMInterface, obj_value: float = None):
+
+        self.value: float = obj_value if obj_value is not None else obj.eval(fem)
+        self.direction: str | float = obj.direction
+
+    def __repr__(self):
+        return str(self.value)
+
+
+class ObjectivesFunc:
+    """複数の値を返す関数を単一の float を返す関数に分割する。"""
+
+    def __init__(self, fun: Callable[..., Sequence[float]], n_return: int):
+        # Optimizer に追加される数と一致することを保証したいので
+        # n_returns が必要
+        self._called: list[bool] | None = None
+        self._values: list[bool] | None = None
+        self.fun: Callable[..., Sequence[float]] = fun
+        self.n_return: int = n_return
+
+    def get_fun_that_returns_ith_value(self, i):
+
+        if i not in range(self.n_return):
+            raise IndexError(
+                _(
+                    en_message='Index {i} is over n_return={n_return}.',
+                    jp_message='インデックス {i} は n_return={n_return} を超えています。',
+                    i=i, n_return=self.n_return
+                )
+            )
+
+        # iter として提供する callable オブジェクト
+        # self の情報にもアクセスする必要があり
+        # それぞれが iter された時点での i 番目という
+        # 情報も必要なのでこのスコープで定義する必要がある
+        # noinspection PyMethodParameters
+        class NthFunc:
+
+            def __init__(self_, i_):
+                # 何番目の要素であるかを保持
+                self_.i = i_
+
+            def __call__(self_, *args, **kwargs) -> float:
+                # 何番目の要素であるか
+                i_ = self_.i
+
+                # 一度も呼ばれていなければ評価する
+                if self._called is None:
+                    self._values = self.fun(*args, **kwargs)
+                    self._called = [False for __ in self._values]
+
+                    assert len(self._values) == self.n_return, _(
+                        en_message='The number of return values of {fun_name} is {n_values}. '
+                                   'This is inconsistent with the specified n_return; {n_return}.',
+                        jp_message='{fun_name} の実行結果の値の数は {n_values} でした。'
+                                   'これは指定された n_return={n_return} と一致しません。',
+                        fun_name=self.fun.__name__,
+                        n_values=len(self._values),
+                        n_return=self.n_return,
+                    )
+
+                # i_ が呼ばれたのでフラグを立てる
+                self._called[i_] = True
+                value = self._values[i_]
+
+                # すべてのフラグが立ったならクリアする
+                if all(self._called):
+                    self._called = None
+                    self._values = None
+
+                # 値を返す
+                return value
+
+            # noinspection PyPropertyDefinition
+            @property
+            def __globals__(self_):
+                # ScapeGoat 実装への対処
+                if hasattr(self.fun, '__globals__'):
+                    return self.fun.__globals__
+                else:
+                    return {}
+
+        # N 番目の値を返す関数を返す
+        f = NthFunc(i)
+
+        return f
+
+
+class Objectives(dict[str, Objective]):
+    pass
+
+
+class Constraint(Function):
+    lower_bound: float | None
+    upper_bound: float | None
+    hard: bool
+    _using_fem: bool | None = None
+    _opt: AbstractOptimizer
+
+    @property
+    def using_fem(self) -> bool:
+        if self._using_fem is None:
+            return self._opt.fem._check_using_fem(self.fun)
+        else:
+            return self._using_fem
+
+    @using_fem.setter
+    def using_fem(self, value: bool | None):
+        self._using_fem = value
+
+
+class ConstraintResult:
+
+    def __init__(
+            self,
+            cns: Constraint,
+            fem: AbstractFEMInterface,
+            cns_value: float = None,
+            constraint_enhancement: float = None,  # offset により scipy.minimize が拘束違反の解を返す問題を回避する
+            constraint_scaling: float = None,  # scaling により scipy.minimize が拘束違反の解を返す問題を回避する
+    ):
+
+        self.value: float = cns_value if cns_value is not None else cns.eval(fem)
+        self.lower_bound: float | None = cns.lower_bound
+        self.upper_bound: float | None = cns.upper_bound
+        self.hard: bool = cns.hard
+        self.ce = constraint_enhancement or 0.
+        self.cs = constraint_scaling or 1.
+
+    def __repr__(self):
+        return str(self.value)
+
+    def calc_violation(self) -> dict[str, float]:
+        value = self.value
+        out = {}
+        if self.lower_bound is not None:
+            out.update({'lower_bound': self.cs * (self.lower_bound - value) + self.ce})
+        if self.upper_bound is not None:
+            out.update({'upper_bound': self.cs * (value - self.upper_bound) + self.ce})
+        return out
+
+    def check_violation(self) -> str | None:
+        violation = self.calc_violation()
+        for l_or_u, value in violation.items():
+            if value > 0:
+                return l_or_u
+        return None
+
+
+class Constraints(dict[str, Constraint]):
+    pass
+
+
+Fidelity: TypeAlias = float | str | None
+
+
+SubSampling: TypeAlias = int
+
+
+TrialInput: TypeAlias = dict[str, Variable]
+TrialOutput: TypeAlias = dict[str, ObjectiveResult]
+TrialConstraintOutput: TypeAlias = dict[str, ConstraintResult]

pyfemtet/opt/problem/variable_manager/__init__.py

@@ -0,0 +1,20 @@
+from ._variable_manager import *
+from ._string_as_expression import *
+
+__all__ = [
+    'SupportedVariableTypes',
+    'Parameter',
+    'Variable',
+    'NumericVariable',
+    'NumericParameter',
+    'CategoricalVariable',
+    'CategoricalParameter',
+    'Expression',
+    'ExpressionFromFunction',
+    # 'NumericExpressionFromFunction',
+    # 'CategoricalExpressionFromFunction',
+    'ExpressionFromString',
+    'VariableManager',
+    'SympifyError',
+    'InvalidExpression',
+]