pyfemtet 1.0.10__py3-none-any.whl → 1.1.0__py3-none-any.whl

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/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/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/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/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/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 を取得

pyfemtet/opt/visualization/plotter/main_figure_creator.py

@@ -1,3 +1,5 @@
+from collections import defaultdict
+
 import numpy as np
 import pandas as pd
 import plotly.graph_objs as go
@@ -6,7 +8,7 @@ import plotly.express as px
 from pyfemtet._util.df_util import *
 from pyfemtet.opt.history import *
 from pyfemtet.opt.problem.problem import MAIN_FIDELITY_NAME
-from pyfemtet._i18n import Msg
+from pyfemtet._i18n import Msg, _
 
 
 __all__ = [
@@ -15,51 +17,83 @@ __all__ = [
     'get_objective_plot',
 ]
 
+# ===== i18n =====
+def _i18n_not_defined_default():
+    return _('Not included in the evaluation.',
+             '評価対象外')
+
+
+# optimality
+_LOCALIZED_OPTIMALITY = _('Optimality', '最適かどうか')
+
+
+def _i18n_optimality(value, is_single_objective) -> str:
+    if value is True:
+        if is_single_objective:
+            return _('optimal', '最適解')
+        else:
+            return _('non dominated', '非劣解')
+    elif value is False:
+        if is_single_objective:
+            return _('not optimal', '最適でない解')
+        else:
+            return _('dominated', '劣解')
+    else:
+        return _i18n_not_defined_default()
+
+
+(_color_mapping_single_objective := defaultdict(lambda: '#888888')).update({
+    _i18n_optimality(True, True): "#007bff",
+    _i18n_optimality(False, True): "#6c757d",
+})
+(_color_mapping_multi_objective := defaultdict(lambda: '#888888')).update({
+    _i18n_optimality(True, False): "#007bff",
+    _i18n_optimality(False, False): "#6c757d",
+})
 
-class _ColorSet:
-    non_domi = {True: '#007bff', False: '#6c757d'}  # color
 
+# feasibility
+_LOCALIZED_FEASIBILITY = _('Feasibility', '実行可能性')
 
-class _SymbolSet:
-    feasible = {True: 'circle', False: 'circle-open'}  # style
 
+def _i18n_feasibility(value) -> str:
+    if value is True:
+        return _('feasible', '実行可能')
+    elif value is False:
+        return _('infeasible', '実行不可能')
+    else:
+        return _i18n_not_defined_default()
 
-class _LanguageSet:
 
-    feasible = {'label': 'feasibility', True: True, False: False}
-    non_domi = {'label': 'optimality', True: True, False: False}
+(_symbol_mapping := defaultdict(lambda: 'square-open')).update({
+    _i18n_feasibility(True): 'circle',
+    _i18n_feasibility(False): 'circle-open',
+})
 
-    def __init__(self):
-        self.feasible = {
-            'label': Msg.LEGEND_LABEL_CONSTRAINT,
-            True: Msg.LEGEND_LABEL_FEASIBLE,
-            False: Msg.LEGEND_LABEL_INFEASIBLE,
-        }
-        self.non_domi = {
-            'label': Msg.LEGEND_LABEL_OPTIMAL,
-            True: Msg.LEGEND_LABEL_NON_DOMI,
-            False: Msg.LEGEND_LABEL_DOMI,
-        }
 
-    def localize(self, df):
-        # 元のオブジェクトを変更しないようにコピー
-        cdf = df.copy()
+# common
+def _i18n_df(df, is_single_objective):
+    # 元の df を変更しないようにコピー
+    df = df.copy()
 
-        # feasible, non_domi の localize
-        cdf[self.feasible['label']] = [self.feasible[v] for v in cdf['feasibility']]
-        cdf[self.non_domi['label']] = [self.non_domi[v] for v in cdf['optimality']]
+    # feasibility 列のデータに対し、
+    # <翻訳された列名>: <グラフに表示するデータ> に
+    # 変換した df を作る。
+    df[_LOCALIZED_FEASIBILITY] = [_i18n_feasibility(v)
+                                 for v in df['feasibility']]
 
-        return cdf
+    # optimality も同様
+    df[_LOCALIZED_OPTIMALITY] = [_i18n_optimality(v, is_single_objective)
+                                 for v in df['optimality']]
 
+    return df
 
-_ls = _LanguageSet()
-_cs = _ColorSet()
-_ss = _SymbolSet()
 
+# ===== main =====
 
 def get_hypervolume_plot(_: History, df: pd.DataFrame) -> go.Figure:
 
-    df = _ls.localize(df)
+    df = _i18n_df(df, is_single_objective=False)
 
     # メインデータを抽出
     df = get_partial_df(df, equality_filters=MAIN_FILTER)
@@ -113,7 +147,7 @@ def get_default_figure(history, df) -> go.Figure:
 
 def _get_single_objective_plot(history: History, df: pd.DataFrame):
 
-    df: pd.DataFrame = _ls.localize(df)
+    df: pd.DataFrame = _i18n_df(df, is_single_objective=True)
     obj_name = history.obj_names[0]
 
     # 「成功した試行数」を表示するために
@@ -275,7 +309,7 @@ def _get_single_objective_plot(history: History, df: pd.DataFrame):
 
 def _get_multi_objective_pairplot(history: History, df: pd.DataFrame):
 
-    df = _ls.localize(df)
+    df = _i18n_df(df, is_single_objective=False)
     df_main = get_partial_df(df, equality_filters=MAIN_FILTER)
 
     obj_names = history.obj_names
@@ -289,21 +323,27 @@ def _get_multi_objective_pairplot(history: History, df: pd.DataFrame):
         history.obj_names for _ in sub_fidelity_names
     ]
 
+    print('===== _color_mapping_multi_objective =====')
+    print(df_main)
+    print(f'{_color_mapping_multi_objective=}')
+
     common_kwargs = dict(
-        color=_ls.non_domi['label'],
-        color_discrete_map={
-            _ls.non_domi[True]: _cs.non_domi[True],
-            _ls.non_domi[False]: _cs.non_domi[False],
-        },
-        symbol=_ls.feasible['label'],
-        symbol_map={
-            _ls.feasible[True]: _ss.feasible[True],
-            _ls.feasible[False]: _ss.feasible[False],
-        },
+        color=_LOCALIZED_OPTIMALITY,
+        color_discrete_map=_color_mapping_multi_objective,
+        symbol=_LOCALIZED_FEASIBILITY,
+        symbol_map=_symbol_mapping,
         custom_data=['trial'],
         category_orders={
-            _ls.feasible['label']: (_ls.feasible[False], _ls.feasible[True]),
-            _ls.non_domi['label']: (_ls.non_domi[False], _ls.non_domi[True]),
+            _LOCALIZED_FEASIBILITY: (
+                _i18n_feasibility(None),  # True, False でなければなんでもよい
+                _i18n_feasibility(False),
+                _i18n_feasibility(True),
+            ),
+            _LOCALIZED_OPTIMALITY: (
+                _i18n_optimality(None, False),
+                _i18n_optimality(False, False),
+                _i18n_optimality(True, False),
+            ),
         },
     )
 
@@ -404,7 +444,7 @@ def _get_multi_objective_pairplot(history: History, df: pd.DataFrame):
 
 def get_objective_plot(history: History, df: pd.DataFrame, obj_names: list[str]) -> go.Figure:
 
-    df = _ls.localize(df)
+    df = _i18n_df(df, is_single_objective=False)
 
     df_main = get_partial_df(df, equality_filters=MAIN_FILTER)
 
@@ -418,20 +458,22 @@ def get_objective_plot(history: History, df: pd.DataFrame, obj_names: list[str])
     ]
 
     common_kwargs = dict(
-        color=_ls.non_domi['label'],
-        color_discrete_map={
-            _ls.non_domi[True]: _cs.non_domi[True],
-            _ls.non_domi[False]: _cs.non_domi[False],
-        },
-        symbol=_ls.feasible['label'],
-        symbol_map={
-            _ls.feasible[True]: _ss.feasible[True],
-            _ls.feasible[False]: _ss.feasible[False],
-        },
+        color=_LOCALIZED_OPTIMALITY,
+        color_discrete_map=_color_mapping_multi_objective,
+        symbol=_LOCALIZED_FEASIBILITY,
+        symbol_map=_symbol_mapping,
         custom_data=['trial'],
         category_orders={
-            _ls.feasible['label']: (_ls.feasible[False], _ls.feasible[True]),
-            _ls.non_domi['label']: (_ls.non_domi[False], _ls.non_domi[True]),
+            _LOCALIZED_FEASIBILITY: (
+                _i18n_feasibility(None),  # True, False でなければなんでもよい
+                _i18n_feasibility(False),
+                _i18n_feasibility(True),
+            ),
+            _LOCALIZED_OPTIMALITY: (
+                _i18n_optimality(None, False),
+                _i18n_optimality(False, False),
+                _i18n_optimality(True, False),
+            ),
         },
     )
 

{pyfemtet-1.0.10.dist-info → pyfemtet-1.1.0.dist-info}/METADATA

@@ -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.dist-info → pyfemtet-1.1.0.dist-info}/RECORD

@@ -29,9 +29,9 @@ pyfemtet/logger/__init__.py,sha256=lofBrZHr0P1hsxPUiPG1SQqKxCuSBk8zGnR7vUfCHYw,5
 pyfemtet/logger/_impl.py,sha256=uJ9el3kR-A4W2DvO_G5A6k9z2u1lkyl7GSvZ68uPy-U,6321
 pyfemtet/opt/__init__.py,sha256=1LcwTddtoi8plemxkzmX0YEKiNpAZvKn9OoNQysyDLE,339
 pyfemtet/opt/exceptions.py,sha256=M_O7jm20Y4e_QxsKF6tnEl-OrAtErUOj6hNT7eEXCO4,1327
-pyfemtet/opt/femopt.py,sha256=etPQ1vJAsnv8nLV4ddJBK56__a55Bsaz68AJNF6NJQM,23573
+pyfemtet/opt/femopt.py,sha256=Zht_H_eaTUwUcA7XFlzod0mGoJzTOZckqRK3VuwjaHM,23716
 pyfemtet/opt/history/__init__.py,sha256=pUp3SO4R7RGzmpNDLBg_pQH0X2yzBd-oqsHXWmB33os,201
-pyfemtet/opt/history/_history.py,sha256=A8kygZXNXtySzpXqsceoFDI912W6NbTdd4KoMjbS8bk,54154
+pyfemtet/opt/history/_history.py,sha256=6n4EZnyBZxGaP7jcHv5PgryFtdE9HotLa6NN1zE6Ops,54158
 pyfemtet/opt/history/_hypervolume.py,sha256=_IvGH71ZNreWvDQCG815Q2hS1OEvPFPQhUnNXf1UxRQ,4449
 pyfemtet/opt/history/_optimality.py,sha256=6vLySZmrrklr04Qir0hGethTykf8NYFod88NDGrBrG0,2407
 pyfemtet/opt/interface/__init__.py,sha256=b2lfkBL-UPbzJppIqSgtUqHSHitPLQa6DRuH91nDZK8,1905
@@ -64,17 +64,18 @@ pyfemtet/opt/meta_script/__main__.py,sha256=9-QM6eZOLpZ_CxERpRu3RAMqpudorSJdPCiK
 pyfemtet/opt/meta_script/sample/sample.bas,sha256=2iuSYMgPDyAdiSDVGxRu3avjcZYnULz0l8e25YBa7SQ,27966
 pyfemtet/opt/meta_script/sample/sample.femprj,sha256=6_0ywhgXxZjdzZzQFog8mgMUEjKNCFVNlEgAWoptovk,292885
 pyfemtet/opt/optimizer/__init__.py,sha256=A4QYeF0KHEFdwoxLfkDND7ikDQ186Ryy3oXEGdakFSg,463
-pyfemtet/opt/optimizer/_base_optimizer.py,sha256=_FmdtisooWgKP3aAqT2MEoqMMxZ6sSZOR9QGiJMbtks,33533
+pyfemtet/opt/optimizer/_base_optimizer.py,sha256=o7XYqAJywX-gnXu2iyKXRKAhyIklZxbAuLitTn23_-Q,37445
+pyfemtet/opt/optimizer/_trial_queue.py,sha256=Yv6JlfVCYOiCukllfxk79xU4_utmxwRA3gcCWpdyG9k,2919
 pyfemtet/opt/optimizer/optuna_optimizer/__init__.py,sha256=u2Bwc79tkZTU5dMbhzzrPQi0RlFg22UgXc-m9K9G6wQ,242
 pyfemtet/opt/optimizer/optuna_optimizer/_optuna_attribute.py,sha256=7eZsruVCGgMlcnf3a9Vf55FOEE-D7V777MJQajI12Cw,1842
-pyfemtet/opt/optimizer/optuna_optimizer/_optuna_optimizer.py,sha256=rnQjWoxXVNDFRj8Htjb8AXa12_EWbP3qUiR3RsK5sh0,28810
+pyfemtet/opt/optimizer/optuna_optimizer/_optuna_optimizer.py,sha256=2hWxS-PZ-oQyPw1cDfW5e6Tiu2bAUmE9Wo9WR01e2zc,32863
 pyfemtet/opt/optimizer/optuna_optimizer/_pof_botorch/__init__.py,sha256=BFbMNvdXqV9kl1h340pW2sq0-cwNFV5dfTo6UnNnX2M,179
 pyfemtet/opt/optimizer/optuna_optimizer/_pof_botorch/debug-pof-botorch.reccsv,sha256=K6oI9jPi_5yayhBrI9Tm1RX3PoWWKo74TOdqnaPsIy8,1746
 pyfemtet/opt/optimizer/optuna_optimizer/_pof_botorch/enable_nonlinear_constraint.py,sha256=jq8cfkZuEkdd8Gvlr3Do4dl48bKSm9Uu7AcEy1dAf6U,9901
 pyfemtet/opt/optimizer/optuna_optimizer/_pof_botorch/pof_botorch_sampler.py,sha256=qOAQOiC7xW1aGZ7JbMPYVjc9FEHi3hYffOfcXpy4rhI,48642
 pyfemtet/opt/optimizer/optuna_optimizer/wat_ex14_parametric_jp.femprj,sha256=-M54MTNrV7muZWPm9Tjptd6HDdtgUFBsRroC6ytyqa0,180970
 pyfemtet/opt/optimizer/scipy_optimizer/__init__.py,sha256=oXx2JAVLvgz0WwIXAknuV4p2MupaiutYYvjI8hXcFwc,45
-pyfemtet/opt/optimizer/scipy_optimizer/_scipy_optimizer.py,sha256=sZxpb-qnDn1KmwgvZmFgVwCKpTPTGw7Yrlmq3DNin0Q,12796
+pyfemtet/opt/optimizer/scipy_optimizer/_scipy_optimizer.py,sha256=BhlvVi3fugDjaDqoyi3glUR0N7NOxne9E92V-BvBOt4,13079
 pyfemtet/opt/prediction/__init__.py,sha256=-XYo-l5YFjExMtqMKj1YUAhmGSQq_0YITS0qizj2Xbs,104
 pyfemtet/opt/prediction/_botorch_utils.py,sha256=cXQlQ_oC6cQaI5kGIYANlqDJPdkGEA_zK2gtJpluJNE,6001
 pyfemtet/opt/prediction/_gpytorch_modules_extension.py,sha256=B_qUtFn06dQENOmUOObbCpkeASUKI5JpXROx8zYeaq0,5224
@@ -165,14 +166,14 @@ pyfemtet/opt/visualization/history_viewer/result_viewer/tutorial_files/tutorial_
 pyfemtet/opt/visualization/history_viewer/result_viewer/tutorial_files/tutorial_gau_ex08_parametric.femprj,sha256=uPqOara56FAt_T4x2P6tvcIXnISw_fX7RECbVoJlAFs,280214
 pyfemtet/opt/visualization/plotter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyfemtet/opt/visualization/plotter/contour_creator.py,sha256=bvGGWNBLZawHq0fAIHfZOUAXw0f9GTlNROiJThoXZ2A,3043
-pyfemtet/opt/visualization/plotter/main_figure_creator.py,sha256=9RXz6Wt52MiSz3Hbew6sDq6KZrYU8ojvhCTHSEup6Ys,16403
+pyfemtet/opt/visualization/plotter/main_figure_creator.py,sha256=a_HK6EUruQBncI8vEIZnrDorPr2EdPICLKU4Er97WtQ,17761
 pyfemtet/opt/visualization/plotter/parallel_plot_creator.py,sha256=VRhT0CUG1mCHDoVO8e6LR_-FiD0QB3GsB95016iXmYc,802
 pyfemtet/opt/visualization/plotter/pm_graph_creator.py,sha256=V26HIbPF1jEVAZ9r1Izsi2zcVz84l4RhZUTJV9jPqp8,11019
 pyfemtet/opt/wat_ex14_parametric_jp.femprj,sha256=dMwQMt6yok_PbZLyxPYdmg5wJQwgQDZ4RhS76zdGLGk,177944
 pyfemtet/opt/worker_status.py,sha256=xSVW9lcw5jzYBwnmlVzk-1zCCyvmXVOH6EoRjqVbE9M,3605
-pyfemtet-1.0.10.dist-info/LICENSE,sha256=LWUL5LlMGjSRTvsalS8_fFuwS4VMw18fJSNWFwDK8pc,1060
-pyfemtet-1.0.10.dist-info/LICENSE_THIRD_PARTY.txt,sha256=8_9-cgzTpmeuCqItPZb9-lyAZcH2Qp9sZTU_hYuOZIQ,191
-pyfemtet-1.0.10.dist-info/METADATA,sha256=rWboOw8yO1pC_MZQEdb7He_jMw2V4oEEBK9rJ_hQDP8,3468
-pyfemtet-1.0.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-pyfemtet-1.0.10.dist-info/entry_points.txt,sha256=Tsb_l_8Z6pyyq2tRfuKiwfJUV3nq_cHoLS61foALtsg,134
-pyfemtet-1.0.10.dist-info/RECORD,,
+pyfemtet-1.1.0.dist-info/LICENSE,sha256=LWUL5LlMGjSRTvsalS8_fFuwS4VMw18fJSNWFwDK8pc,1060
+pyfemtet-1.1.0.dist-info/LICENSE_THIRD_PARTY.txt,sha256=8_9-cgzTpmeuCqItPZb9-lyAZcH2Qp9sZTU_hYuOZIQ,191
+pyfemtet-1.1.0.dist-info/METADATA,sha256=U-_Mn8IbOEgQjZ6IGa85S6pccNEW6Mq_t8XtkW2svVY,3503
+pyfemtet-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pyfemtet-1.1.0.dist-info/entry_points.txt,sha256=Tsb_l_8Z6pyyq2tRfuKiwfJUV3nq_cHoLS61foALtsg,134
+pyfemtet-1.1.0.dist-info/RECORD,,