pyfemtet 1.0.10__tar.gz → 1.1.0__tar.gz

{pyfemtet-1.0.10 → pyfemtet-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyfemtet
-Version: 1.0.10
+Version: 1.1.0
 Summary: Design parameter optimization using Femtet.
 License: MIT
 Author: pyfemtet
@@ -21,6 +21,7 @@ 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: frozendict (>=2.4.6)
 Requires-Dist: numpy (>=2.0.0,<3)
 Requires-Dist: openpyxl (>=3.1.2,<4)
 Requires-Dist: optuna (>=3.4.0,<5.0.0)

{pyfemtet-1.0.10 → pyfemtet-1.1.0}/pyfemtet/opt/femopt.py

@@ -168,6 +168,12 @@ class FEMOpt:
     ):
         self.opt.add_other_output(name, fun, args, kwargs)
 
+    def add_trial(
+            self,
+            parameters: dict[str, SupportedVariableTypes],
+    ):
+        self.opt.add_trial(parameters)
+
     def add_sub_fidelity_model(
             self,
             name: str,

{pyfemtet-1.0.10 → pyfemtet-1.1.0}/pyfemtet/opt/history/_history.py

@@ -116,9 +116,9 @@ class TrialState(StrEnum):
         elif state == TrialState.unknown_error:
             e = Exception()
         elif state == TrialState.hard_constraint_violation:
-            e = HardConstraintViolation
+            e = HardConstraintViolation()
         elif state == TrialState.skipped:
-            e = SkipSolve
+            e = SkipSolve()
         else:
             e = None
         return e

{pyfemtet-1.0.10 → pyfemtet-1.1.0}/pyfemtet/opt/optimizer/_base_optimizer.py

@@ -14,6 +14,7 @@ from pyfemtet.opt.exceptions import *
 from pyfemtet.opt.worker_status import *
 from pyfemtet.opt.problem.problem import *
 from pyfemtet.opt.problem.variable_manager import *
+from pyfemtet.opt.optimizer._trial_queue import *
 from pyfemtet.logger import get_module_logger
 
 __all__ = [
@@ -68,6 +69,7 @@ class AbstractOptimizer:
     n_trials: int | None
     timeout: float | None
     seed: int | None
+    include_queued_in_n_trials: bool
 
     # problem
     variable_manager: VariableManager
@@ -94,6 +96,7 @@ class AbstractOptimizer:
         self.seed = None
         self.n_trials = None
         self.timeout = None
+        self.include_queued_in_n_trials = False
 
         # Problem
         self.variable_manager = VariableManager()
@@ -113,6 +116,7 @@ class AbstractOptimizer:
         self.entire_status: WorkerStatus = WorkerStatus(ENTIRE_PROCESS_STATUS_KEY)
         self.worker_status: WorkerStatus = WorkerStatus('worker-status')
         self.worker_status_list: list[WorkerStatus] = [self.worker_status]
+        self.trial_queue: TrialQueue = TrialQueue()
         self._done_setup_before_parallel = False
         self._done_load_problem_from_fem = False
         self._worker_index: int | str | None = None
@@ -368,6 +372,12 @@ class AbstractOptimizer:
         _duplicated_name_check(name, self.sub_fidelity_models.keys())
         self.sub_fidelity_models._update(name, sub_fidelity_model, fidelity)
 
+    def add_trial(
+            self,
+            parameters: dict[str, SupportedVariableTypes],
+    ):
+        self.trial_queue.enqueue(parameters)
+
     def get_variables(self, format: Literal['dict', 'values', 'raw'] = 'dict'):
         return self.variable_manager.get_variables(
             format=format,
@@ -383,6 +393,21 @@ class AbstractOptimizer:
 
     # ===== private =====
 
+    def _setup_enqueued_trials(self):
+        # Insert initial trial
+        params: dict = self.variable_manager.get_variables(format='dict', filter='parameter')
+        self.trial_queue.enqueue_first(params, flags={_IS_INITIAL_TRIAL_FLAG_KEY: True})
+
+        # Remove trials included in history
+        tried: list[dict] = get_tried_list_from_history(
+            self.history,
+            equality_filters=MAIN_FILTER,
+        )
+        self.trial_queue.remove_tried(tried)
+
+        # Remove duplicated
+        self.trial_queue.remove_duplicated()
+
     def _should_solve(self, history):
         return self.solve_condition(history)
 
@@ -921,6 +946,61 @@ class AbstractOptimizer:
             # resolve evaluation order
             self.variable_manager.resolve()
 
+            # check the enqueued trials is
+            # compatible with current optimization
+            # problem setup
+            history_set = set(self.history.prm_names)
+            for t in self.trial_queue.queue:
+                params: dict = t.d
+                enqueued_set: set = set(params.keys())
+
+                # Warning if over
+                if len(enqueued_set - history_set) > 0:
+                    logger.warning(
+                        _(
+                            en_message='Enqueued parameter set contains '
+                                       'more parameters than the optimization '
+                                       'problem setup. The extra parameters '
+                                       'will be ignored.\n'
+                                       'Enqueued set: {enqueued_set}\n'
+                                       'Setup set: {history_set}\n'
+                                       'Parameters ignored: {over_set}',
+                            jp_message='予約された入力変数セットは'
+                                       '最適化のセットアップで指定されたよりも'
+                                       '多くの変数を含んでいます。'
+                                       'そのような変数は無視されます。\n'
+                                       '予約された入力変数: {enqueued_set}\n'
+                                       '最適化する変数: {history_set}\n'
+                                       '無視される変数: {over_set}',
+                            enqueued_set=enqueued_set,
+                            history_set=history_set,
+                            over_set=enqueued_set - history_set,
+                        )
+                    )
+
+                # Error if not enough
+                if len(history_set - enqueued_set) > 0:
+                    raise ValueError(
+                        _(
+                            en_message='The enqueued parameter set lacks '
+                                       'some parameters to be optimized.\n'
+                                       'Enqueued set: {enqueued_set}\n'
+                                       'Parameters to optimize: {history_set}\n'
+                                       'Lacked set: {lacked_set}',
+                            jp_message='予約された入力変数セットに'
+                                       '変数が不足しています。\n'
+                                       '予約された変数: {enqueued_set}\n'
+                                       '最適化する変数: {history_set}\n'
+                                       '足りない変数: {lacked_set}',
+                            enqueued_set=enqueued_set,
+                            history_set=history_set,
+                            lacked_set=history_set - enqueued_set,
+                        )
+                    )
+
+            # remove duplicated enqueued trials
+            self._setup_enqueued_trials()
+
             self._done_setup_before_parallel = True
 
     def _setup_after_parallel(self):

pyfemtet-1.1.0/pyfemtet/opt/optimizer/_trial_queue.py

@@ -0,0 +1,101 @@
+from typing import Sequence
+from frozendict import frozendict
+
+from pyfemtet.opt.history import History, TrialState
+from pyfemtet.opt.problem.variable_manager import SupportedVariableTypes
+
+
+__all__ = [
+    'TrialQueue',
+    'get_tried_list_from_history',
+    '_IS_INITIAL_TRIAL_FLAG_KEY',
+]
+
+
+_IS_INITIAL_TRIAL_FLAG_KEY = 'is_initial_trial'
+
+
+class EnqueuedTrial:
+
+    def __init__(self, d: dict[str, SupportedVariableTypes], flags: dict = None):
+        self.d = d
+        self.flags = flags or {}
+
+    @staticmethod
+    def d_type_verified(d) -> dict:
+        out = {}
+        for k, v in d.items():
+            if isinstance(v, str):
+                out.update({k: v})
+            else:
+                out.update({k: float(v)})
+        return out
+
+    def get_hashed_id(self):
+        return hash(frozendict(self.d_type_verified(self.d)))
+
+
+class TrialQueue:
+
+    def __init__(self):
+        self.queue: list[EnqueuedTrial] = []
+
+    def __len__(self):
+        return len(self.queue)
+
+    def enqueue_first(self, d: dict[str, SupportedVariableTypes], flags: dict = None):
+        self.queue.insert(0, EnqueuedTrial(d, flags=flags))
+
+    def enqueue(self, d: dict[str, SupportedVariableTypes], flags: dict = None):
+        self.queue.append(EnqueuedTrial(d, flags=flags))
+
+    def dequeue(self) -> dict[str, SupportedVariableTypes] | None:
+        if len(self.queue) == 0:
+            return None
+        return self.queue.pop(0).d
+
+    def remove_duplicated(self):
+        indices_to_remove = []
+        all_ids = [t.get_hashed_id() for t in self.queue]
+
+        # 先に queue に入れられたものから
+        # 順に見ていく
+        # indices は sorted となるはず
+        seen_ids = set()
+        for i, id in enumerate(all_ids):
+            if id in seen_ids:
+                indices_to_remove.append(i)
+            else:
+                seen_ids.add(id)
+
+        # 削除
+        for i in indices_to_remove[::-1]:
+            self.queue.pop(i)
+
+    def remove_tried(self, tried_list: Sequence[dict[str, SupportedVariableTypes]]):
+        indices_to_remove = []
+        tried_id = [EnqueuedTrial(tried).get_hashed_id() for tried in tried_list]
+        for i, t in enumerate(self.queue):
+            if t.get_hashed_id() in tried_id:
+                indices_to_remove.append(i)
+        for i in indices_to_remove[::-1]:
+            self.queue.pop(i)
+
+
+def get_tried_list_from_history(
+        history: History,
+        equality_filters=None,
+) -> list[dict[str, SupportedVariableTypes]]:
+    out = []
+    df = history.get_df(equality_filters=equality_filters)
+    for _, row in df.iterrows():
+        # Want to retry if unknown error
+        # so don't count it as tried.
+        if row['state'] in (
+                TrialState.unknown_error,
+                TrialState.undefined,
+        ):
+            continue
+        d = row[history.prm_names].to_dict()
+        out.append(d)
+    return out

{pyfemtet-1.0.10 → pyfemtet-1.1.0}/pyfemtet/opt/optimizer/optuna_optimizer/_optuna_optimizer.py

@@ -12,7 +12,8 @@ import numpy as np
 
 import optuna
 from optuna.samplers import TPESampler
-from optuna.study import MaxTrialsCallback
+from optuna.study import Study, MaxTrialsCallback
+from optuna.trial import FrozenTrial, TrialState as OptunaTrialState
 from optuna_integration.dask import DaskStorage
 
 from pyfemtet._i18n import _
@@ -28,8 +29,9 @@ from pyfemtet.opt.optimizer._base_optimizer import *
 from pyfemtet.opt.optimizer.optuna_optimizer._optuna_attribute import OptunaAttribute
 from pyfemtet.opt.optimizer.optuna_optimizer._pof_botorch.pof_botorch_sampler import PoFBoTorchSampler
 from pyfemtet.opt.worker_status import WorkerStatus
+from pyfemtet.opt.optimizer._trial_queue import _IS_INITIAL_TRIAL_FLAG_KEY
 
-logger = get_module_logger('opt.optimizer', False)
+logger = get_module_logger('opt.optimizer', True)
 
 remove_all_output(get_optuna_logger())
 
@@ -38,6 +40,69 @@ warnings.filterwarnings('ignore', 'Argument ``constraints_func`` is an experimen
                         optuna.exceptions.ExperimentalWarning)
 
 
+_MESSAGE_ENQUEUED = 'Enqueued trial.'
+
+
+class MaxTrialsCallbackExcludingEnqueued(MaxTrialsCallback):
+    def __call__(self, study: Study, trial: FrozenTrial) -> None:
+        """
+        queue を考慮して終了条件を決定する
+
+        if n_trials <= 0:
+            -q_wait >= n_trials
+
+            ```
+            q_comp q_wait
+               |    |
+               v    v
+             f=====....0.............
+            ------|----+------------->
+                  n_trials=-4 (<=0)
+            ```
+
+        else:
+            (s_comp := comp - q_comp) >= n_trials
+
+            ```
+              q_comp    s_comp
+                 |       |
+                 v       v
+              f========0===..........
+            -----------+--|---------->
+                          n_trials=4 (>0)
+            ```
+
+        """
+
+        # 与えられた state (=COMPLETE) の trials を取得
+        trials = study.get_trials(deepcopy=False, states=self._states)
+
+        # n_trials が負か 0 なら残り WAITING 数と比較
+        if self._n_trials <= 0:
+            waiting_trials = study.get_trials(deepcopy=False, states=(OptunaTrialState.WAITING,))
+            enqueued_trials = [trial for trial in waiting_trials if trial.user_attrs.get('enqueued')]
+
+            if -len(enqueued_trials) >= self._n_trials:
+                study.stop()
+
+        # 正なら (初回を除く enqueued trial) を除く
+        # COMPLETE 数 (=初回 + sampled_complete) と比較
+        else:
+
+            n_complete = len(trials)
+            n_enqueued_complete = len([
+                trial for trial in trials
+                if (
+                    trial.user_attrs.get('enqueued', False)
+                    and not trial.user_attrs.get(_IS_INITIAL_TRIAL_FLAG_KEY, False)
+                )
+            ])
+            n_sampled_complete = n_complete - n_enqueued_complete
+
+            if n_sampled_complete >= self._n_trials:
+                study.stop()
+
+
 class OptunaOptimizer(AbstractOptimizer):
     """
     An optimizer class utilizing Optuna for hyperparameter optimization.
@@ -274,13 +339,40 @@ class OptunaOptimizer(AbstractOptimizer):
 
     def _get_callback(self, n_trials: int):
 
+        states = (optuna.trial.TrialState.COMPLETE,)
+
         # restart である場合、追加 N 回と見做す
         if self.history.is_restart:
-            df = self.history.get_df(equality_filters=MAIN_FILTER)
-            n_existing_succeeded_trials = len(df[df['state'] == TrialState.succeeded])
-            n_trials = n_trials + n_existing_succeeded_trials
 
-        return MaxTrialsCallback(n_trials, states=(optuna.trial.TrialState.COMPLETE,))
+            study = optuna.load_study(
+                study_name=self.study_name,
+                storage=self.storage,
+            )
+            trials = study.get_trials(deepcopy=False, states=states)
+            n_complete = len(trials)
+
+            if self.include_queued_in_n_trials:
+                # 追加 n_trials 回と見做す
+                n_trials = n_trials + n_complete
+
+            else:
+                if n_trials > 0:
+                    # 追加 n_trials 回と見做すが、
+                    # Callback で n_enqueued_complete を足しているので
+                    # そのぶんを引かなければならない
+                    n_enqueued_complete = len([trial for trial in trials if trial.user_attrs.get('enqueued')])
+                    n_trials = n_trials + n_complete - n_enqueued_complete
+
+                else:
+                    # queue_wait と比較するので
+                    # 何も補正しなくていい
+                    pass
+
+        if self.include_queued_in_n_trials:
+            Class = MaxTrialsCallback
+        else:
+            Class = MaxTrialsCallbackExcludingEnqueued
+        return Class(n_trials, states=states)
 
     def _setup_before_parallel(self):
 
@@ -321,30 +413,44 @@ class OptunaOptimizer(AbstractOptimizer):
         # if TPESampler and re-starting,
         # create temporary study to avoid error
         # with many pruned trials.
-        if issubclass(self.sampler_class, optuna.samplers.TPESampler) \
-                and self.history.is_restart:
-            # get unique tmp file
-            tmp_storage_path = tempfile.mktemp(suffix='.db')
-            self._existing_storage_path = self.storage_path
-            self.storage_path = tmp_storage_path
+        if (
+                issubclass(self.sampler_class, optuna.samplers.TPESampler)
+                and self.history.is_restart
+        ):
+
+            # If there is a WAITING trial in queue,
+            # do nothing (because the callback cannot
+            # update the WAITING trial in the existing
+            # study.)
 
             # load existing study
             existing_study = optuna.load_study(
-                study_name=self.study_name,
-                storage=f'sqlite:///{self._existing_storage_path}',
-            )
-
-            # create new study
-            tmp_study = optuna.create_study(
                 study_name=self.study_name,
                 storage=f'sqlite:///{self.storage_path}',
-                load_if_exists=True,
-                directions=['minimize'] * len(self.objectives),
             )
 
-            # Copy COMPLETE trials to temporary study.
-            existing_trials = existing_study.get_trials(states=(optuna.trial.TrialState.COMPLETE,))
-            tmp_study.add_trials(existing_trials)
+            if len(existing_study.get_trials(deepcopy=False, states=(OptunaTrialState.WAITING,))) == 0:
+
+                # get unique tmp file
+                tmp_storage_path = tempfile.mktemp(suffix='.db')
+                self._existing_storage_path = self.storage_path
+                self.storage_path = tmp_storage_path
+
+                # create new study
+                tmp_study = optuna.create_study(
+                    study_name=self.study_name,
+                    storage=f'sqlite:///{self.storage_path}',
+                    load_if_exists=True,
+                    directions=['minimize'] * len(self.objectives),
+                )
+
+                # Copy COMPLETE trials to temporary study.
+                existing_trials = existing_study.get_trials(
+                    states=(
+                        optuna.trial.TrialState.COMPLETE,
+                    )
+                )
+                tmp_study.add_trials(existing_trials)
 
         # setup storage
         client = get_client()
@@ -368,9 +474,18 @@ class OptunaOptimizer(AbstractOptimizer):
             # set objective names
             study.set_metric_names(list(self.objectives.keys()))
 
-            # initial trial
-            params = self.variable_manager.get_variables(format='dict', filter='parameter')
-            study.enqueue_trial(params, user_attrs={"message": "Initial values"})
+            # Add enqueued trials
+            for t in self.trial_queue.queue:
+                is_initial_step = t.flags.get(_IS_INITIAL_TRIAL_FLAG_KEY, False)
+                params: dict[str, SupportedVariableTypes] = t.d
+                study.enqueue_trial(
+                    params,
+                    user_attrs={
+                        'message': _MESSAGE_ENQUEUED,
+                        'enqueued': True,
+                        _IS_INITIAL_TRIAL_FLAG_KEY: is_initial_step,
+                    },
+                )
 
     def _setup_after_parallel(self):
         # reseed
@@ -539,6 +654,9 @@ class OptunaOptimizer(AbstractOptimizer):
                     # and add callback to copy-back
                     # from processing study to existing one.
                     def copy_back(_, trial):
+                        # ここで existing_study 内の WAITING を
+                        # 更新したり削除したりできないので
+                        # tpe_addressing は WAITING がない状態でしか使わない
                         existing_study.add_trial(trial)
 
                     self.callbacks.append(copy_back)

{pyfemtet-1.0.10 → pyfemtet-1.1.0}/pyfemtet/opt/optimizer/scipy_optimizer/_scipy_optimizer.py

@@ -92,6 +92,12 @@ class ScipyOptimizer(AbstractOptimizer):
                 jp_message='`ScipyOptimizer` では n_trials は指定できません。'
             ))
 
+    def add_trial(self, parameters: dict[str, SupportedVariableTypes]):
+        raise NotImplementedError(_(
+            en_message='You cannot use `add_trial()` in `ScipyOptimizer`.',
+            jp_message='`ScipyOptimizer` では `add_trial()` は使えません。',
+        ))
+
     def _get_x0(self) -> np.ndarray:
 
         # params を取得