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

pyfemtet/opt/interface/_surrogate/_base.py

@@ -1,129 +0,0 @@
-from typing import Optional, List, Any
-from abc import ABC
-
-import numpy as np
-import pandas as pd
-
-from pyfemtet.logger import get_module_logger
-from pyfemtet.opt._femopt_core import History, Objective
-from pyfemtet.opt.interface._base import FEMInterface
-from pyfemtet.opt.optimizer._base import AbstractOptimizer
-
-logger = get_module_logger('opt.interface', __name__)
-
-
-class SurrogateModelInterfaceBase(FEMInterface, ABC):
-    def __init__(
-            self,
-            history_path: str = None,
-            train_history: History = None,
-            _output_directions: dict[int, str | float] | list[str | float] = None,
-    ):
-
-        self.train_history: History
-        self.model: Any
-        self.prm: dict[str, float] = dict()
-        self.obj: dict[str, float] = dict()
-        self.df_prm: pd.DataFrame
-        self.df_obj: pd.DataFrame
-        self._output_directions = _output_directions
-
-        # history_path が与えられた場合、train_history をコンストラクトする
-        if history_path is not None:
-            train_history = History(history_path=history_path)
-
-        # train_history が与えられるかコンストラクトされている場合
-        if train_history is not None:
-            # 学習データを準備する
-            df_prm = train_history.get_df()[train_history.prm_names]
-            df_obj = train_history.get_df()[train_history.obj_names]
-
-            # obj の名前を作る
-            for obj_name in train_history.obj_names:
-                self.obj[obj_name] = np.nan
-
-            # prm の名前を作る
-            for prm_name in train_history.prm_names:
-                self.prm[prm_name] = np.nan
-
-            self.train_history = train_history
-
-        # history から作らない場合、引数チェック
-        else:
-            # assert len(train_x) == len(train_y)
-            raise NotImplementedError
-
-        self.df_prm = df_prm
-        self.df_obj = df_obj
-
-        # _output_directions が与えられている場合、
-        # history から objective の設定を読み込む
-        if self._output_directions is not None:
-            self._load_problem_from_me: bool = True
-
-        FEMInterface.__init__(
-            self,
-            train_history=train_history,  # コンストラクト済み train_history を渡せば並列計算時も何もしなくてよい
-        )
-
-
-    def load_objective(self, opt) -> None:
-        from pyfemtet.opt._femopt_core import Objective
-
-        assert self._output_directions is not None
-
-        if isinstance(self._output_directions, dict):
-
-            for index, direction in self._output_directions.items():
-                obj_name = self.train_history.obj_names[index]
-                opt.objectives[obj_name] = Objective(
-                    lambda obj_name_=obj_name: self.obj[obj_name_],
-                    name=obj_name,
-                    direction=direction,
-                    args=(),
-                    kwargs={},
-                )
-
-        elif isinstance(self._output_directions, list) \
-                or isinstance(self._output_directions, tuple):
-
-            obj_names = self.train_history.obj_names
-            assert len(self._output_directions) == len(obj_names)
-
-            for obj_name, direction in zip(obj_names, self._output_directions):
-                opt.objectives[obj_name] = Objective(
-                    lambda obj_name_=obj_name: self.obj[obj_name_],
-                    name=obj_name,
-                    direction=direction,
-                    args=(),
-                    kwargs={},
-                )
-
-        else:
-            raise ValueError('Invalid _output_directions')
-
-    def filter_feasible(self, x: np.ndarray, y: np.ndarray, return_feasibility=False):
-        feasible_idx = np.where(~np.isnan(y.sum(axis=1)))
-        if return_feasibility:
-            # calculated or not
-            feas = np.zeros((len(y), 1), dtype=float)
-            feas[feasible_idx] = 1.
-            return x, feas
-        else:
-            return x[feasible_idx], y[feasible_idx]
-
-    def _setup_after_parallel(self, *args, **kwargs):
-        opt: AbstractOptimizer = kwargs['opt']
-        obj: Objective
-
-        # add_objective された目的のうち、
-        # training data に含まれる名前で
-        # あるものは fun を上書き
-        for obj_name, obj in opt.objectives.items():
-            if obj_name in self.train_history.obj_names:
-                obj.fun = lambda obj_name_=obj_name: self.obj[obj_name_]
-
-    def update_parameter(self, parameters: pd.DataFrame, with_warning=False) -> Optional[List[str]]:
-        for i, row in parameters.iterrows():
-            name, value = row['name'], row['value']
-            self.prm[name] = value

pyfemtet/opt/interface/_surrogate/_chaospy.py

@@ -1,71 +0,0 @@
-import numpy as np
-import pandas as pd
-
-from pyfemtet.logger import get_module_logger
-from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
-from pyfemtet.opt.prediction.polynomial_expansion import PolynomialExpansionModel
-
-
-logger = get_module_logger('opt.interface', __name__)
-
-
-class PolynomialChaosInterface(SurrogateModelInterfaceBase):
-
-    model: PolynomialExpansionModel  # surrogate_func_expansion
-
-    def train(self):
-        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values)
-        assert len(x) > 0, 'No feasible results in training data.'
-        self.model.fit(x, y)
-
-    def _setup_after_parallel(self, *args, **kwargs):
-
-        # # update objectives
-        # SurrogateModelInterfaceBase._setup_after_parallel(
-        #     self, *args, **kwargs
-        # )
-
-        # train model
-        self.model = PolynomialExpansionModel()
-        self.model.set_bounds_from_history(self.train_history)
-        self.train()
-
-    def update(self, parameters: pd.DataFrame) -> None:
-        # self.prm 更新
-        SurrogateModelInterfaceBase.update_parameter(
-            self, parameters
-        )
-
-        # history.prm_name 順に並べ替え
-        x = np.array([self.prm[k] for k in self.train_history.prm_names])
-
-        # prediction
-        dist_mean, _ = self.model.predict(x)
-
-        # 目的関数の更新
-        self.obj = {obj_name: value for obj_name, value in zip(self.train_history.obj_names, dist_mean)}
-
-
-if __name__ == '__main__':
-    import os
-    from pyfemtet.opt._femopt_core import History
-
-    os.chdir(os.path.dirname(__file__))
-
-    history = History(history_path='sample.csv')
-    fem = PolynomialChaosInterface(history=history)
-
-    import pandas as pd
-    df = history.get_df()
-    parameters = pd.DataFrame(
-        dict(
-            name=history.prm_names,
-            value=[1. for _ in history.prm_names]
-        )
-    )
-
-    fem._setup_after_parallel()
-
-    fem.update(
-        parameters
-    )

pyfemtet/opt/interface/_surrogate/_singletaskgp.py

@@ -1,71 +0,0 @@
-import numpy as np
-import pandas as pd
-from scipy.stats.distributions import norm
-
-from pyfemtet.core import SolveError
-from pyfemtet.logger import get_module_logger
-from pyfemtet.opt.interface._surrogate._base import SurrogateModelInterfaceBase
-from pyfemtet.opt.prediction.single_task_gp import SingleTaskGPModel
-
-from pyfemtet._message.messages import Message as Msg
-
-
-logger = get_module_logger('opt.interface', __name__)
-
-
-class PoFBoTorchInterface(SurrogateModelInterfaceBase):
-    model_f: SingleTaskGPModel
-    model: SingleTaskGPModel
-    threshold = 0.5
-
-    def train(self):
-        # df そのまま用いて training する
-        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values)
-        assert len(x) > 0, 'No feasible results in training data.'
-        self.model.fit(x, y)
-
-    def train_f(self):
-        # df そのまま用いて training する
-        x, y = self.filter_feasible(self.df_prm.values, self.df_obj.values, return_feasibility=True)
-        if y.min() == 1:  # feasible values only
-            self.model_f.predict = lambda *args, **kwargs: (1., 0.001)  # mean, std
-        self.model_f.fit(x, y)
-
-    def _setup_after_parallel(self, *args, **kwargs):
-
-        # update objectives
-        SurrogateModelInterfaceBase._setup_after_parallel(
-            self, *args, **kwargs
-        )
-
-        # model training
-        self.model = SingleTaskGPModel()
-        self.model.set_bounds_from_history(self.train_history)
-        self.train()
-
-        # model_f training
-        self.model_f = SingleTaskGPModel(is_noise_free=False)
-        self.model_f.set_bounds_from_history(self.train_history)
-        self.train_f()
-
-    def update(self, parameters: pd.DataFrame) -> None:
-        # self.prm 更新
-        SurrogateModelInterfaceBase.update_parameter(
-            self, parameters
-        )
-
-        # train_history.prm_name 順に並べ替え
-        x = np.array([self.prm[k] for k in self.train_history.prm_names])
-
-        # feasibility の計算
-        mean_f, std_f = self.model_f.predict(np.array([x]))
-        pof = 1. - norm.cdf(self.threshold, loc=mean_f, scale=std_f)
-        if pof < self.threshold:
-            raise SolveError(Msg.INFO_POF_IS_LESS_THAN_THRESHOLD)
-
-        # 実際の計算(現時点で mean は train_history.obj_names 順)
-        _mean, _std = self.model.predict(np.array([x]))
-        mean = _mean[0]
-
-        # 目的関数の更新
-        self.obj = {obj_name: value for obj_name, value in zip(self.train_history.obj_names, mean)}

pyfemtet/opt/interface/_surrogate_excel.py

@@ -1,102 +0,0 @@
-import re
-from pathlib import Path
-
-from pyfemtet.opt._femopt_core import History
-from pyfemtet.opt.interface._base import FEMInterface
-from pyfemtet.opt.interface._surrogate._singletaskgp import PoFBoTorchInterface
-from pyfemtet.opt.interface._excel_interface import ExcelInterface
-
-
-class PoFBoTorchInterfaceWithExcelSettingsInterface(
-    PoFBoTorchInterface,
-    ExcelInterface,
-    FEMInterface,
-):
-
-    def __init__(
-            self,
-
-            # SurrogateModel
-            history_path: str = None, train_history: History = None,
-
-            # Excel
-            input_xlsm_path: str or Path = None,
-            input_sheet_name: str = None,
-            output_xlsm_path: str or Path = None,
-            output_sheet_name: str = None,
-            constraint_xlsm_path: str or Path = None,
-            constraint_sheet_name: str = None,
-            procedure_name: str = None,
-            procedure_args: list or tuple = None,
-            # connect_method: str = 'auto',  # or 'new'
-            procedure_timeout: float or None = None,
-            setup_xlsm_path: str or Path = None,
-            setup_procedure_name: str = None,
-            setup_procedure_args: list or tuple = None,
-            teardown_xlsm_path: str or Path = None,
-            teardown_procedure_name: str = None,
-            teardown_procedure_args: list or tuple = None,
-            related_file_paths: list[str or Path] = None,
-            visible: bool = False,
-            display_alerts: bool = False,
-            terminate_excel_when_quit: bool = None,
-            interactive: bool = True,
-            use_named_range: bool = True,
-    ):
-        PoFBoTorchInterface.__init__(
-            self,
-            history_path,
-            train_history,
-        )
-
-        connect_method = 'new'
-
-        ExcelInterface.__init__(
-            self,
-            input_xlsm_path,
-            input_sheet_name,
-            output_xlsm_path,
-            output_sheet_name,
-            constraint_xlsm_path,
-            constraint_sheet_name,
-            procedure_name,
-            procedure_args,
-            connect_method,  # or 'new'
-            procedure_timeout,
-            setup_xlsm_path,
-            setup_procedure_name,
-            setup_procedure_args,
-            teardown_xlsm_path,
-            teardown_procedure_name,
-            teardown_procedure_args,
-            related_file_paths,
-            visible,
-            display_alerts,
-            terminate_excel_when_quit,
-            interactive,
-            use_named_range,
-        )
-
-    def load_parameter(self, opt, raise_if_no_keyword=True) -> None:
-        ExcelInterface.load_parameter(self, opt, raise_if_no_keyword)
-
-    def load_objective(self, opt, raise_if_no_keyword=True) -> None:
-        ExcelInterface.load_objective(self, opt, raise_if_no_keyword)
-
-    def load_constraint(self, opt, raise_if_no_keyword=False):
-        ExcelInterface.load_constraint(self, opt, raise_if_no_keyword)
-
-    def _setup_before_parallel(self, client):
-        PoFBoTorchInterface._setup_before_parallel(self, client)
-        ExcelInterface._setup_before_parallel(self, client)
-
-    def _setup_after_parallel(self, *args, **kwargs):
-        PoFBoTorchInterface._setup_after_parallel(self, *args, **kwargs)
-        ExcelInterface._setup_after_parallel(self, *args, **kwargs)
-
-    def update(self, parameters) -> None:
-        PoFBoTorchInterface.update(self, parameters)
-
-    def quit(self):
-        PoFBoTorchInterface.quit(self)
-        ExcelInterface.quit(self)