pyfemtet 0.9.4__py3-none-any.whl → 1.0.0a0__py3-none-any.whl

pyfemtet/opt/optimizer/_scipy.py

@@ -1,159 +0,0 @@
-# typing
-import logging
-from typing import Iterable
-
-# built-in
-import os
-
-# 3rd-party
-import numpy as np
-import pandas as pd
-import scipy.optimize
-from scipy.optimize import minimize, OptimizeResult
-
-# pyfemtet relative
-from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
-from pyfemtet.opt.optimizer import AbstractOptimizer, logger, OptimizationMethodChecker
-from pyfemtet.core import MeshError, ModelError, SolveError
-from pyfemtet._message import Msg
-
-
-class StopIteration2(Exception):
-    pass
-
-
-class StopIterationCallback:
-    def __init__(self, opt):
-        self.opt: ScipyOptimizer = opt
-        self.res: OptimizeResult = None
-
-    def stop_iteration(self):
-        # stop iteration gimmick
-        # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
-        if self.opt.minimize_kwargs['method'] == "trust-constr":
-            raise StopIteration2  # supports nothing
-        elif (
-                self.opt.minimize_kwargs['method'] == 'TNC'
-                or self.opt.minimize_kwargs['method'] == 'SLSQP'
-                or self.opt.minimize_kwargs['method'] == 'COBYLA'
-        ):
-            raise StopIteration2  # supports xk
-        else:
-            raise StopIteration  # supports xk , intermediate_result and StopIteration
-
-
-    def __call__(self, xk=None, intermediate_result=None):
-        self.res = intermediate_result
-        if self.opt.entire_status.get() == OptimizationStatus.INTERRUPTING:
-            self.opt.worker_status.set(OptimizationStatus.INTERRUPTING)
-            self.stop_iteration()
-
-
-class ScipyMethodChecker(OptimizationMethodChecker):
-    def check_incomplete_bounds(self, raise_error=True): return True
-    def check_seed(self, raise_error=True):
-        logger.warning(Msg.WARN_SCIPY_DOESNT_NEED_SEED)
-        return True
-
-
-class ScipyOptimizer(AbstractOptimizer):
-    """Optimizer using ```scipy```.
-
-    This class provides an interface for the optimization
-    engine using Scipy. For more details, please refer to
-    the Scipy documentation.
-
-    See Also:
-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
-
-    Args:
-        **minimize_kwargs:
-            The keyword arguments of
-            ```scipy.optimize.minimize```.
-
-    Attributes:
-        res (OptimizeResult):
-            The return value of ```scipy.optimize.minimize```.
-
-    """
-
-    def __init__(
-            self,
-            **minimize_kwargs,
-    ):
-        super().__init__()
-
-        # define members
-        self.minimize_kwargs: dict = dict(
-            method='L-BFGS-B',
-        )
-        self.minimize_kwargs.update(minimize_kwargs)
-        self.res: OptimizeResult = None
-        self.method_checker: OptimizationMethodChecker = ScipyMethodChecker(self)
-        self.stop_iteration_callback = StopIterationCallback(self)
-
-    def _objective(self, x: np.ndarray):  # x: candidate parameter
-        # update parameter
-        df = self.get_parameter('df')
-        df['value'] = x
-        self.fem.update_parameter(df)
-
-        # strict constraints
-        ...
-
-        # fem
-        try:
-            _, obj_values, cns_values = self.f(x)
-        except (ModelError, MeshError, SolveError) as e:
-            # 現在の技術的にエラーが起きたらスキップできない
-            logger.error(Msg.ERR_FEM_FAILED_AND_CANNOT_CONTINUE)
-            raise StopIteration2
-
-        # constraints
-        ...
-
-        # # check interruption command
-        # if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
-        #     self.worker_status.set(OptimizationStatus.INTERRUPTING)
-        #     raise StopOptimize
-
-        # objectives to objective
-
-        return obj_values[0]
-
-    def _setup_before_parallel(self):
-        pass
-
-    def run(self):
-
-        # create init
-        x0 = self.get_parameter('values')
-
-        # create bounds
-        if 'bounds' not in self.minimize_kwargs.keys():
-            bounds = []
-            for i, row in self.get_parameter('df').iterrows():
-                lb, ub = row['lower_bound'], row['upper_bound']
-                if lb is None: lb = -np.inf
-                if ub is None: ub = np.inf
-                bounds.append([lb, ub])
-            self.minimize_kwargs.update(
-                {'bounds': bounds}
-            )
-
-        # run optimize
-        try:
-            res = minimize(
-                fun=self._objective,
-                x0=x0,
-                **self.minimize_kwargs,
-                callback=self.stop_iteration_callback,
-            )
-        except StopIteration2:
-            res = None
-            logger.warn(Msg.WARN_INTERRUPTED_IN_SCIPY)
-
-        if res is None:
-            self.res = self.stop_iteration_callback.res
-        else:
-            self.res = res

pyfemtet/opt/optimizer/_scipy_scalar.py

@@ -1,127 +0,0 @@
-# typing
-import logging
-from typing import Iterable
-
-# built-in
-import os
-
-# 3rd-party
-import numpy as np
-import pandas as pd
-import scipy.optimize
-from scipy.optimize import minimize_scalar, OptimizeResult
-
-# pyfemtet relative
-from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
-from pyfemtet.opt.optimizer import AbstractOptimizer, logger, OptimizationMethodChecker
-from pyfemtet.core import MeshError, ModelError, SolveError
-from pyfemtet._message import Msg
-
-
-class ScipyScalarMethodChecker(OptimizationMethodChecker):
-    def check_incomplete_bounds(self, raise_error=True): return True
-    def check_seed(self, raise_error=True):
-        logger.warning(Msg.WARN_SCIPY_DOESNT_NEED_SEED)
-        return True
-
-
-class ScipyScalarOptimizer(AbstractOptimizer):
-    """Optimizer using ```scipy```.
-
-    This class provides an interface for the optimization
-    engine using Scipy. For more details, please refer to
-    the Scipy documentation.
-
-    See Also:
-        https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html
-
-    Args:
-        **minimize_kwargs:
-            The keyword arguments of
-            ```scipy.optimize.minimize_scalar```.
-
-    Attributes:
-        res (OptimizeResult):
-            The return value of ```scipy.optimize.minimize_scalar```.
-
-    """
-
-    def __init__(
-            self,
-            **minimize_kwargs,
-    ):
-        super().__init__()
-
-        # define members
-        self.minimize_kwargs: dict = dict()
-        self.minimize_kwargs.update(minimize_kwargs)
-        self.res: OptimizeResult = None
-        self.method_checker: OptimizationMethodChecker = ScipyScalarMethodChecker(self)
-
-    def _objective(self, x: float):  # x: candidate parameter
-        # update parameter
-
-        df = self.get_parameter('df')
-        df['value'] = x
-        self.fem.update_parameter(df)
-
-        # strict constraints
-        ...
-
-        # fem
-        try:
-            _, obj_values, cns_values = self.f(x)
-        except (ModelError, MeshError, SolveError) as e:
-            # 現状、エラーが起きたらスキップできない
-            raise StopIteration
-
-        # constraints
-        ...
-
-        # check interruption command
-        if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
-            self.worker_status.set(OptimizationStatus.INTERRUPTING)
-            raise StopIteration
-
-        # objectives to objective
-
-        return obj_values[0]
-
-    def _setup_before_parallel(self):
-        pass
-
-    def run(self):
-
-        # create init
-        params = self.get_parameter()
-        assert len(params) == 1, print(f'{params} parameter(s) are passed.')
-
-        # create bounds
-        if 'bounds' not in self.minimize_kwargs.keys():
-            bounds = []
-
-            row = self.get_parameter('df')
-            lb, ub = row['lower_bound'].iloc[0], row['upper_bound'].iloc[0]
-
-            if lb is None and ub is None:
-                pass
-            elif lb is None or ub is None:
-                raise ValueError('Both lower and upper bounds must be set.')
-            else:
-                bounds = [lb, ub]
-                self.minimize_kwargs.update(
-                    {'bounds': bounds}
-                )
-
-        # run optimize
-        try:
-            res = minimize_scalar(
-                fun=self._objective,
-                **self.minimize_kwargs,
-            )
-        except StopIteration:
-            res = None
-            logger.warn('Optimization has been interrupted. '
-                        'Note that you cannot acquire the OptimizationResult.')
-
-        self.res = res

pyfemtet/opt/optimizer/parameter.py

@@ -1,113 +0,0 @@
-from graphlib import TopologicalSorter
-from dataclasses import dataclass
-import inspect
-from typing import Optional, Callable, Any, Tuple, Dict
-
-import numpy as np
-import pandas as pd
-
-
-@dataclass
-class Variable:
-    name: str
-    value: float
-    pass_to_fem: Optional[bool] = True
-    properties: Optional[dict[Any]] = None
-
-
-@dataclass
-class Parameter(Variable):
-    lower_bound: Optional[float] = None
-    upper_bound: Optional[float] = None
-    step: Optional[float] = None
-
-
-@dataclass
-class Expression(Variable):
-    # fun に params を自動で代入するので positional args は実装しない
-    fun: Optional[Callable] = None
-    kwargs: Optional[Dict] = None
-
-
-class ExpressionEvaluator:
-    def __init__(self):
-        self.variables = {}  # Parameter 又は計算された Expression が入る
-        self.parameters = {}
-        self.expressions = {}
-        self.dependencies = {}
-        self.evaluation_order = []
-
-    def add_parameter(self, prm: Parameter):
-        self.variables[prm.name] = prm
-        self.parameters[prm.name] = prm
-        self.dependencies[prm.name] = set()
-
-    def add_expression(self, exp: Expression):
-        self.expressions[exp.name] = exp
-
-        # params は Python 変数として使える文字のみからなる文字列のリスト
-        params = inspect.signature(exp.fun).parameters
-        self.dependencies[exp.name] = set(params) - set(exp.kwargs.keys())
-
-    def resolve(self):
-        ts = TopologicalSorter(self.dependencies)
-        self.evaluation_order = list(ts.static_order())
-
-    def evaluate(self):
-        # order 順に見ていき、expression なら計算して variables を更新する
-        for var_name in self.evaluation_order:
-            if var_name in self.expressions.keys():
-                # 現在の expression に関して parameter 部分の引数 kwargs を作成
-                kwargs = {param: self.variables[param].value for param in self.dependencies[var_name]}
-
-                # fun に すべての kwargs を入れて expression の value を更新
-                exp: Expression = self.expressions[var_name]
-                kwargs.update(exp.kwargs)
-                exp.value = exp.fun(**kwargs)
-
-                # 計算済み variables に追加
-                self.variables[var_name] = exp
-
-    def get_variables(self, format='dict', filter_pass_to_fem=False, filter_parameter=False):
-        """format: dict, values, df, raw(list of Variable object)"""
-
-        # リストを作成
-        vars = [self.variables[name] for name in self.evaluation_order if name in self.variables]
-
-        # 必要なら FEM に直接使うもののみ取り出し
-        if filter_pass_to_fem:
-            vars = [var for var in vars if var.pass_to_fem]
-
-        # 必要なら parameter のみ取り出し
-        if filter_parameter:
-            vars = [var for var in vars if isinstance(var, Parameter)]
-
-        if format == 'raw':
-            return vars
-
-        elif format == 'dict':
-            return {var.name: var.value for var in vars}
-
-        elif format == 'values':
-            return np.array([var.value for var in vars]).astype(float)
-
-        elif format == 'df':
-            data = dict(
-                    name=[var.name for var in vars],
-                    value=[var.value for var in vars],
-                    properties=[var.properties for var in vars],
-                )
-            if filter_parameter:
-                data.update(
-                    dict(
-                        lower_bound=[var.lower_bound for var in vars],
-                        upper_bound=[var.upper_bound for var in vars],
-                    )
-                )
-            return pd.DataFrame(data)
-
-        else:
-            raise NotImplementedError(f'invalid format: {format}. Valid formats are `dict`, `values`, `df` and `raw`(= list of Variables).')
-
-    def get_parameter_names(self):
-        return list(self.parameters.keys())

pyfemtet/opt/prediction/_base.py

@@ -1,61 +0,0 @@
-from abc import ABC, abstractmethod
-
-import numpy as np
-import pandas as pd
-
-from pyfemtet.opt._femopt_core import History
-
-
-class PredictionModelBase(ABC):
-    """Simple Abstract surrogate model class."""
-
-    @abstractmethod
-    def fit(self, x: np.ndarray, y: np.ndarray):
-        """
-        Args:
-            x (np.ndarray): Input. (Point number) rows and (variable number) columns.
-            y (np.ndarray): Output. (Point number) rows and (objective number) columns.
-        """
-
-    @abstractmethod
-    def predict(self, x: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-        """
-        Args:
-            x (np.ndarray): Input. (Point number) rows and (variable number) columns.
-        Returns:
-            np.ndarray: (Point number) rows and (objective number) columns. Index 0 is mean and index 1 is std.
-        """
-
-
-class PyFemtetPredictionModel:
-
-    def __init__(self, history: History, df: pd.DataFrame, MetaModel: type):
-        assert issubclass(MetaModel, PredictionModelBase)
-        self.meta_model: PredictionModelBase = MetaModel()
-
-        from pyfemtet.opt.prediction.single_task_gp import SingleTaskGPModel
-        if isinstance(self.meta_model, SingleTaskGPModel):
-            self.meta_model.set_bounds_from_history(
-                history,
-                df,
-            )
-
-        self.obj_names = history.obj_names
-        self.prm_names = history.prm_names
-        self.df = df
-        self.x: np.ndarray = df[self.prm_names].values
-        self.y: np.ndarray = df[self.obj_names].values
-
-    def get_prm_index(self, prm_name):
-        return self.prm_names.index(prm_name) if prm_name in self.prm_names else None
-
-    def get_obj_index(self, obj_name):
-        return self.obj_names.index(obj_name) if obj_name in self.obj_names else None
-
-    def fit(self) -> None:
-        self.meta_model.fit(self.x, self.y)
-
-    def predict(self, x: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-        assert len(x.shape) == 2
-        assert x.shape[1] == len(self.prm_names)
-        return self.meta_model.predict(x)

pyfemtet/opt/prediction/single_task_gp.py

@@ -1,119 +0,0 @@
-import numpy as np
-import torch
-import gpytorch
-
-from botorch.models import SingleTaskGP
-from botorch.models.transforms.input import Normalize
-from botorch.models.transforms.outcome import Standardize
-from botorch.fit import fit_gpytorch_mll
-from gpytorch.mlls import ExactMarginalLogLikelihood
-
-from pyfemtet.opt.prediction._base import PredictionModelBase
-
-
-DEVICE = 'cpu'
-DTYPE = torch.float64
-
-
-def tensor(x_):
-    return torch.tensor(x_, dtype=DTYPE, device=DEVICE)
-
-
-class SingleTaskGPModel(PredictionModelBase):
-    """Simple interface surrogate model using ```SingleTaskGP```.
-
-    See Also:
-        https://botorch.org/api/models.html#botorch.models.gp_regression.SingleTaskGP
-    """
-
-    def __init__(self, bounds=None, is_noise_free=True):
-        if bounds is not None:
-            if isinstance(bounds, np.ndarray):
-                self.bounds = tensor(bounds).T
-            elif isinstance(bounds, list) or isinstance(bounds, tuple):
-                self.bounds = tensor(np.array(bounds)).T
-            else:
-                raise NotImplementedError('Bounds must be a np.ndarray or list or tuple.')
-        else:
-            self.bounds = None
-        self.is_noise_free = is_noise_free
-        self._standardizer: Standardize = None
-
-    def set_bounds_from_history(self, history, df=None):
-        from pyfemtet.opt._femopt_core import History
-        history: History
-        meta_column: str
-
-        if df is None:
-            df = history.get_df()
-
-        columns = df.columns
-
-        target_columns = [
-            col for col, meta_column in zip(columns, history.meta_columns)
-            if meta_column == 'prm_lb' or meta_column == 'prm_ub'
-        ]
-
-        bounds_buff = df.iloc[0][target_columns].values  # 2*len(prm_names) array
-        bounds = bounds_buff.reshape(-1, 2).astype(float)
-        self.bounds = tensor(bounds).T
-
-    # noinspection PyAttributeOutsideInit
-    def fit(self, x: np.ndarray, y: np.ndarray):
-        X = tensor(x)
-        Y = tensor(y)
-
-        # Standardize を SingleTaskGP に任せると
-        # 小さい Variance を勝手に 1e-10 に丸めるので
-        # 外で Standardize してから渡す
-        standardizer = Standardize(m=Y.shape[-1],)
-        std_Y, _ = standardizer.forward(Y)
-        YVar = torch.full_like(Y, 1e-6)
-        self._standardizer = standardizer
-
-        # Fit a Gaussian Process model using the extracted data
-        self.gp = SingleTaskGP(
-            train_X=X,
-            train_Y=std_Y,
-            train_Yvar=YVar if self.is_noise_free else None,
-            input_transform=Normalize(d=X.shape[-1], bounds=self.bounds),
-            # BoTorch 0.13 前後で None を渡すと
-            # Standardize しない挙動は変わらないので None を渡せばよい
-            outcome_transform=None,
-        )
-        mll = ExactMarginalLogLikelihood(self.gp.likelihood, self.gp)
-        fit_gpytorch_mll(mll)
-
-    def predict(self, x: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-        assert len(x.shape) >= 2
-
-        X = tensor(x)
-
-        post = self.gp.posterior(X)
-
-        # fit() で Standardize してから SingleTaskGP に渡したので
-        # posterior は手動で un-standardize する必要がある
-        M, V = self._standardizer.untransform(post.mean, post.variance)
-
-        mean = M.detach().numpy()
-        var = V.detach().numpy()
-        std = np.sqrt(var)
-
-        return mean, std
-
-
-if __name__ == '__main__':
-    dim = 3
-    N = 20
-    bounds = (np.arange(dim*2)**2).reshape((-1, 2))
-    x = np.random.rand(N, dim)
-    x = x * (bounds[:, 1] - bounds[:, 0]) + bounds[:, 0]
-    y = (x ** 2).sum(axis=1, keepdims=True) * 1e-7
-
-    model = SingleTaskGPModel()
-    model.fit(x, y)
-    print(model.predict(np.array([[(b[1] + b[0])/2 for b in bounds]])))
-
-    # 外挿
-    print(model.predict(np.array([[b[1] for b in bounds]])))
-    print(model.predict(np.array([[b[1] * 2 for b in bounds]])))

pyfemtet/opt/samples/femprj_sample/ParametricIF.py

@@ -1,29 +0,0 @@
-from pyfemtet.opt import FemtetInterface, FEMOpt, AbstractOptimizer
-
-
-def ex_in(_, opt: AbstractOptimizer):
-    ex_r, in_r = opt.get_parameter('values')
-    return ex_r - in_r
-
-
-
-if __name__ == '__main__':
-
-    fem = FemtetInterface(
-        parametric_output_indexes_use_as_objective={
-            0: "minimize",
-            1: "minimize",
-            2: "minimize",
-        },
-    )
-
-    femopt = FEMOpt(fem=fem)
-
-    femopt.add_parameter("external_radius", 10, 1, 10)
-    femopt.add_parameter("internal_radius", 5, 1, 10)
-    femopt.add_constraint(ex_in, lower_bound=1, strict=True, args=(femopt.opt,))
-    femopt.set_random_seed(42)
-    femopt.optimize(
-        n_trials=10,
-        n_parallel=1,
-    )

pyfemtet/opt/samples/femprj_sample/ParametricIF_test_result.reccsv

@@ -1,13 +0,0 @@
-"{""femprj_path"": null, ""model_name"": ""test_5""}",prm,prm_lb,prm_ub,prm,prm_lb,prm_ub,obj,obj_direction,obj,obj_direction,obj,obj_direction,,cns,cns_lb,cns_ub,,,,
-,,,,,,,,,,,,,,,,,,,,
-trial,external_radius,external_radius_lower_bound,external_radius_upper_bound,internal_radius,internal_radius_lower_bound,internal_radius_upper_bound,����[Kg] / Cylinder,����[Kg] / Cylinder_direction,����[Pa] / �~�[�[�X�̑������� / �ő�l / Cylinder,����[Pa] / �~�[�[�X�̑������� / �ő�l / Cylinder_direction,�ψ�[m] / �傫�� / �ő�l / Cylinder,�ψ�[m] / �傫�� / �ő�l / Cylinder_direction,non_domi,cns_0,cns_0_lower_bound,cns_0_upper_bound,feasible,hypervolume,message,time
-1,10.0,1.0,10.0,5.0,1.0,10.0,0.08025126265847096,minimize,699391.2949775695,minimize,3.5987515450106034e-07,minimize,True,5.0,1,,True,0.0,initial,2024-07-24 12:03:18.218300
-2,7.587945476302646,1.0,10.0,6.387926357773329,1.0,10.0,0.018829523087730202,minimize,2819410.021640385,minimize,1.9633635574428563e-06,minimize,True,1.2000191185293163,1,,True,0.0072609644545304644,,2024-07-24 12:03:21.608587
-3,8.491983767203795,1.0,10.0,2.9110519961044856,1.0,10.0,0.06578893373109447,minimize,1058372.1746301493,minimize,6.396966778509452e-07,minimize,True,5.580931771099309,1,,True,0.13523816247173967,,2024-07-24 12:03:25.454547
-4,9.488999089406718,1.0,10.0,1.053974646602355,1.0,10.0,0.09344346108490897,minimize,738819.4364388706,minimize,3.9190983806535766e-07,minimize,False,8.435024442804362,1,,True,0.13523816247173967,,2024-07-24 12:03:28.900803
-5,9.838880436025262,1.0,10.0,4.121658022659597,1.0,10.0,0.08482642054771264,minimize,701388.5216985068,minimize,3.6449255450534674e-07,minimize,False,5.717222413365665,1,,True,0.13523816247173967,,2024-07-24 12:03:32.453681
-6,8.455917394686129,1.0,10.0,4.306340483879064,1.0,10.0,0.055191055245607905,minimize,1170551.5363429904,minimize,7.0142545377377e-07,minimize,True,4.149576910807064,1,,True,0.23270321585070972,,2024-07-24 12:03:35.355075
-7,7.5733020568630876,1.0,10.0,4.532076028923693,1.0,10.0,0.038663363226300325,minimize,1680507.878460014,minimize,1.151410183947273e-06,minimize,True,3.041226027939395,1,,True,0.29888894485611545,,2024-07-24 12:03:38.348642
-8,6.64195280415911,1.0,10.0,4.3268559224164935,1.0,10.0,0.02513863374590192,minimize,2992920.10569469,minimize,2.210659794963239e-06,minimize,False,2.3150968817426163,1,,True,0.29888894485611545,,2024-07-24 12:03:41.305751
-9,5.457560349207987,1.0,10.0,3.6301461895178777,1.0,10.0,0.016440094818037845,minimize,5824574.81469252,minimize,4.804776216529427e-06,minimize,False,1.8274141596901092,1,,True,0.29888894485611545,,2024-07-24 12:03:44.694410
-10,7.075956010136126,1.0,10.0,6.0727177168143935,1.0,10.0,0.013058674177275532,minimize,4421271.288534293,minimize,3.2060909560154104e-06,minimize,True,1.0032382933217328,1,,True,0.3600968150317699,,2024-07-24 12:03:47.854562