Add files using upload-large-folder tool

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/artifacts/_list_artifact_meta.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from optuna.artifacts._upload import ArtifactMeta
+from optuna.artifacts._upload import ARTIFACTS_ATTR_PREFIX
+from optuna.study import Study
+from optuna.trial import FrozenTrial
+from optuna.trial import Trial
+
+
+if TYPE_CHECKING:
+    from optuna.storages import BaseStorage
+
+
+def get_all_artifact_meta(
+    study_or_trial: Trial | FrozenTrial | Study, *, storage: BaseStorage | None = None
+) -> list[ArtifactMeta]:
+    """List the associated artifact information of the provided trial or study.
+
+    Args:
+        study_or_trial:
+            A :class:`~optuna.trial.Trial` object, a :class:`~optuna.trial.FrozenTrial`, or
+            a :class:`~optuna.study.Study` object.
+        storage:
+            A storage object. This argument is required only if ``study_or_trial`` is
+            :class:`~optuna.trial.FrozenTrial`.
+
+    Example:
+        An example where this function is useful:
+
+        .. code::
+
+            import os
+
+            import optuna
+
+
+            # Get the storage that contains the study of interest.
+            storage = optuna.storages.get_storage(storage=...)
+
+            # Instantiate the artifact store used for the study.
+            # Optuna does not provide the API that stores the used artifact store information, so
+            # please manage the information in the user side.
+            artifact_store = ...
+
+            # Load study that contains the artifacts of interest.
+            study = optuna.load_study(study_name=..., storage=storage)
+
+            # Fetch the best trial.
+            best_trial = study.best_trial
+
+            # Fetch all the artifact meta connected to the best trial.
+            artifact_metas = optuna.artifacts.get_all_artifact_meta(best_trial, storage=storage)
+
+            download_dir_path = "./best_trial_artifacts/"
+            os.makedirs(download_dir_path, exist_ok=True)
+
+            for artifact_meta in artifact_metas:
+                download_file_path = os.path.join(download_dir_path, artifact_meta.filename)
+                # Download the artifacts to ``download_file_path``.
+                optuna.artifacts.download_artifact(
+                    artifact_store=artifact_store,
+                    artifact_id=artifact_meta.artifact_id,
+                    file_path=download_file_path,
+                )
+
+    Returns:
+        The list of artifact meta in the trial or study.
+        Each artifact meta includes ``artifact_id``, ``filename``, ``mimetype``, and ``encoding``.
+        Note that if :class:`~optuna.study.Study` is provided, we return the information of the
+        artifacts uploaded to ``study``, but not to all the trials in the study.
+    """
+    if isinstance(study_or_trial, Trial) and storage is None:
+        storage = study_or_trial.storage
+    elif isinstance(study_or_trial, Study) and storage is None:
+        storage = study_or_trial._storage
+
+    if storage is None:
+        raise ValueError("storage is required for FrozenTrial.")
+
+    if isinstance(study_or_trial, (Trial, FrozenTrial)):
+        system_attrs = storage.get_trial_system_attrs(study_or_trial._trial_id)
+    else:
+        system_attrs = storage.get_study_system_attrs(study_or_trial._study_id)
+
+    artifact_meta_list: list[ArtifactMeta] = []
+    for attr_key, attr_json_string in system_attrs.items():
+        if not attr_key.startswith(ARTIFACTS_ATTR_PREFIX):
+            continue
+
+        attr_content = json.loads(attr_json_string)
+        artifact_meta = ArtifactMeta(
+            artifact_id=attr_content["artifact_id"],
+            filename=attr_content["filename"],
+            mimetype=attr_content["mimetype"],
+            encoding=attr_content["encoding"],
+        )
+        artifact_meta_list.append(artifact_meta)
+
+    return artifact_meta_list

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/importance/__init__.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from optuna._experimental import warn_experimental_argument
+from optuna.importance._base import BaseImportanceEvaluator
+from optuna.importance._fanova import FanovaImportanceEvaluator
+from optuna.importance._mean_decrease_impurity import MeanDecreaseImpurityImportanceEvaluator
+from optuna.importance._ped_anova import PedAnovaImportanceEvaluator
+from optuna.study import Study
+from optuna.trial import FrozenTrial
+
+
+__all__ = [
+    "BaseImportanceEvaluator",
+    "FanovaImportanceEvaluator",
+    "MeanDecreaseImpurityImportanceEvaluator",
+    "PedAnovaImportanceEvaluator",
+    "get_param_importances",
+]
+
+
+def get_param_importances(
+    study: Study,
+    *,
+    evaluator: BaseImportanceEvaluator | None = None,
+    params: list[str] | None = None,
+    target: Callable[[FrozenTrial], float] | None = None,
+    normalize: bool = True,
+) -> dict[str, float]:
+    """Evaluate parameter importances based on completed trials in the given study.
+
+    The parameter importances are returned as a dictionary where the keys consist of parameter
+    names and their values importances.
+    The importances are represented by non-negative floating point numbers, where higher values
+    mean that the parameters are more important.
+    The returned dictionary is ordered by its values in a descending order.
+    By default, the sum of the importance values are normalized to 1.0.
+
+    If ``params`` is :obj:`None`, all parameter that are present in all of the completed trials are
+    assessed.
+    This implies that conditional parameters will be excluded from the evaluation.
+    To assess the importances of conditional parameters, a :obj:`list` of parameter names can be
+    specified via ``params``.
+    If specified, only completed trials that contain all of the parameters will be considered.
+    If no such trials are found, an error will be raised.
+
+    If the given study does not contain completed trials, an error will be raised.
+
+    .. note::
+
+        If ``params`` is specified as an empty list, an empty dictionary is returned.
+
+    .. seealso::
+
+        See :func:`~optuna.visualization.plot_param_importances` to plot importances.
+
+    Args:
+        study:
+            An optimized study.
+        evaluator:
+            An importance evaluator object that specifies which algorithm to base the importance
+            assessment on.
+            Defaults to
+            :class:`~optuna.importance.FanovaImportanceEvaluator`.
+        params:
+            A list of names of parameters to assess.
+            If :obj:`None`, all parameters that are present in all of the completed trials are
+            assessed.
+        target:
+            A function to specify the value to evaluate importances.
+            If it is :obj:`None` and ``study`` is being used for single-objective optimization,
+            the objective values are used. ``target`` must be specified if ``study`` is being
+            used for multi-objective optimization.
+
+            .. note::
+                Specify this argument if ``study`` is being used for multi-objective
+                optimization. For example, to get the hyperparameter importance of the first
+                objective, use ``target=lambda t: t.values[0]`` for the target parameter.
+        normalize:
+            A boolean option to specify whether the sum of the importance values should be
+            normalized to 1.0.
+            Defaults to :obj:`True`.
+
+            .. note::
+                Added in v3.0.0 as an experimental feature. The interface may change in newer
+                versions without prior notice. See
+                https://github.com/optuna/optuna/releases/tag/v3.0.0.
+
+    Returns:
+        A :obj:`dict` where the keys are parameter names and the values are assessed importances.
+
+    """
+    if evaluator is None:
+        evaluator = FanovaImportanceEvaluator()
+
+    if not isinstance(evaluator, BaseImportanceEvaluator):
+        raise TypeError("Evaluator must be a subclass of BaseImportanceEvaluator.")
+
+    res = evaluator.evaluate(study, params=params, target=target)
+    if normalize:
+        s = sum(res.values())
+        if s == 0.0:
+            n_params = len(res)
+            return dict((param, 1.0 / n_params) for param in res.keys())
+        else:
+            return dict((param, value / s) for (param, value) in res.items())
+    else:
+        warn_experimental_argument("normalize")
+        return res

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/importance/_fanova/__init__.py

@@ -0,0 +1,4 @@
+from optuna.importance._fanova._evaluator import FanovaImportanceEvaluator
+
+
+__all__ = ["FanovaImportanceEvaluator"]

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/importance/_fanova/_fanova.py

@@ -0,0 +1,108 @@
+"""An implementation of `An Efficient Approach for Assessing Hyperparameter Importance`.
+
+See http://proceedings.mlr.press/v32/hutter14.pdf and https://automl.github.io/fanova/cite.html
+for how to cite the original work.
+
+This implementation is inspired by the efficient algorithm in
+`fanova` (https://github.com/automl/fanova) and
+`pyrfr` (https://github.com/automl/random_forest_run) by the original authors.
+
+Differences include relying on scikit-learn to fit random forests
+(`sklearn.ensemble.RandomForestRegressor`) and that it is otherwise written entirely in Python.
+This stands in contrast to the original implementation which is partially written in C++.
+Since Python runtime overhead may become noticeable, included are instead several
+optimizations, e.g. vectorized NumPy functions to compute the marginals, instead of keeping all
+running statistics. Known cases include assessing categorical features with a larger
+number of choices since each choice is given a unique one-hot encoded raw feature.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from optuna._imports import try_import
+from optuna.importance._fanova._tree import _FanovaTree
+
+
+with try_import() as _imports:
+    from sklearn.ensemble import RandomForestRegressor
+
+
+class _Fanova:
+    def __init__(
+        self,
+        n_trees: int,
+        max_depth: int,
+        min_samples_split: int | float,
+        min_samples_leaf: int | float,
+        seed: int | None,
+    ) -> None:
+        _imports.check()
+
+        self._forest = RandomForestRegressor(
+            n_estimators=n_trees,
+            max_depth=max_depth,
+            min_samples_split=min_samples_split,
+            min_samples_leaf=min_samples_leaf,
+            random_state=seed,
+        )
+        self._trees: list[_FanovaTree] | None = None
+        self._variances: dict[int, np.ndarray] | None = None
+        self._column_to_encoded_columns: list[np.ndarray] | None = None
+
+    def fit(
+        self,
+        X: np.ndarray,
+        y: np.ndarray,
+        search_spaces: np.ndarray,
+        column_to_encoded_columns: list[np.ndarray],
+    ) -> None:
+        assert X.shape[0] == y.shape[0]
+        assert X.shape[1] == search_spaces.shape[0]
+        assert search_spaces.shape[1] == 2
+
+        self._forest.fit(X, y)
+
+        self._trees = [_FanovaTree(e.tree_, search_spaces) for e in self._forest.estimators_]
+        self._column_to_encoded_columns = column_to_encoded_columns
+        self._variances = {}
+
+        if all(tree.variance == 0 for tree in self._trees):
+            # If all trees have 0 variance, we cannot assess any importances.
+            # This could occur if for instance `X.shape[0] == 1`.
+            raise RuntimeError("Encountered zero total variance in all trees.")
+
+    def get_importance(self, feature: int) -> tuple[float, float]:
+        # Assert that `fit` has been called.
+        assert self._trees is not None
+        assert self._variances is not None
+
+        self._compute_variances(feature)
+
+        fractions: list[float] | np.ndarray = []
+
+        for tree_index, tree in enumerate(self._trees):
+            tree_variance = tree.variance
+            if tree_variance > 0.0:
+                fraction = self._variances[feature][tree_index] / tree_variance
+                fractions = np.append(fractions, fraction)
+
+        fractions = np.asarray(fractions)
+
+        return float(fractions.mean()), float(fractions.std())
+
+    def _compute_variances(self, feature: int) -> None:
+        assert self._trees is not None
+        assert self._variances is not None
+        assert self._column_to_encoded_columns is not None
+
+        if feature in self._variances:
+            return
+
+        raw_features = self._column_to_encoded_columns[feature]
+        variances = np.empty(len(self._trees), dtype=np.float64)
+
+        for tree_index, tree in enumerate(self._trees):
+            marginal_variance = tree.get_marginal_variance(raw_features)
+            variances[tree_index] = np.clip(marginal_variance, 0.0, None)
+        self._variances[feature] = variances

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/importance/_ped_anova/__init__.py

@@ -0,0 +1,4 @@
+from optuna.importance._ped_anova.evaluator import PedAnovaImportanceEvaluator
+
+
+__all__ = ["PedAnovaImportanceEvaluator"]

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/importance/_ped_anova/evaluator.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+import warnings
+
+import numpy as np
+
+from optuna._experimental import experimental_class
+from optuna.distributions import BaseDistribution
+from optuna.importance._base import _get_distributions
+from optuna.importance._base import _get_filtered_trials
+from optuna.importance._base import _sort_dict_by_importance
+from optuna.importance._base import BaseImportanceEvaluator
+from optuna.importance._ped_anova.scott_parzen_estimator import _build_parzen_estimator
+from optuna.logging import get_logger
+from optuna.study import Study
+from optuna.study import StudyDirection
+from optuna.trial import FrozenTrial
+
+
+_logger = get_logger(__name__)
+
+
+class _QuantileFilter:
+    def __init__(
+        self,
+        quantile: float,
+        is_lower_better: bool,
+        min_n_top_trials: int,
+        target: Callable[[FrozenTrial], float] | None,
+    ):
+        assert 0 <= quantile <= 1, "quantile must be in [0, 1]."
+        assert min_n_top_trials > 0, "min_n_top_trials must be positive."
+
+        self._quantile = quantile
+        self._is_lower_better = is_lower_better
+        self._min_n_top_trials = min_n_top_trials
+        self._target = target
+
+    def filter(self, trials: list[FrozenTrial]) -> list[FrozenTrial]:
+        target, min_n_top_trials = self._target, self._min_n_top_trials
+        sign = 1.0 if self._is_lower_better else -1.0
+        loss_values = sign * np.asarray([t.value if target is None else target(t) for t in trials])
+        err_msg = "len(trials) must be larger than or equal to min_n_top_trials"
+        assert min_n_top_trials <= loss_values.size, err_msg
+
+        def _quantile(v: np.ndarray, q: float) -> float:
+            cutoff_index = int(np.ceil(q * loss_values.size)) - 1
+            return float(np.partition(loss_values, cutoff_index)[cutoff_index])
+
+        cutoff_val = max(
+            np.partition(loss_values, min_n_top_trials - 1)[min_n_top_trials - 1],
+            # TODO(nabenabe0928): After dropping Python3.10, replace below with
+            # np.quantile(loss_values, self._quantile, method="inverted_cdf").
+            _quantile(loss_values, self._quantile),
+        )
+        should_keep_trials = loss_values <= cutoff_val
+        return [t for t, should_keep in zip(trials, should_keep_trials) if should_keep]
+
+
+@experimental_class("3.6.0")
+class PedAnovaImportanceEvaluator(BaseImportanceEvaluator):
+    """PED-ANOVA importance evaluator.
+
+    Implements the PED-ANOVA hyperparameter importance evaluation algorithm.
+
+    PED-ANOVA fits Parzen estimators of :class:`~optuna.trial.TrialState.COMPLETE` trials better
+    than a user-specified baseline. Users can specify the baseline by a quantile.
+    The importance can be interpreted as how important each hyperparameter is to get
+    the performance better than baseline.
+
+    For further information about PED-ANOVA algorithm, please refer to the following paper:
+
+    - `PED-ANOVA: Efficiently Quantifying Hyperparameter Importance in Arbitrary Subspaces
+      <https://arxiv.org/abs/2304.10255>`__
+
+    .. note::
+
+        The performance of PED-ANOVA depends on how many trials to consider above baseline.
+        To stabilize the analysis, it is preferable to include at least 5 trials above baseline.
+
+    .. note::
+
+        Please refer to `the original work <https://github.com/nabenabe0928/local-anova>`__.
+
+    Args:
+        baseline_quantile:
+            Compute the importance of achieving top-``baseline_quantile`` quantile objective value.
+            For example, ``baseline_quantile=0.1`` means that the importances give the information
+            of which parameters were important to achieve the top-10% performance during
+            optimization.
+        evaluate_on_local:
+            Whether we measure the importance in the local or global space.
+            If :obj:`True`, the importances imply how importance each parameter is during
+            optimization. Meanwhile, ``evaluate_on_local=False`` gives the importances in the
+            specified search_space. ``evaluate_on_local=True`` is especially useful when users
+            modify search space during optimization.
+
+    Example:
+        An example of using PED-ANOVA is as follows:
+
+        .. testcode::
+
+            import optuna
+            from optuna.importance import PedAnovaImportanceEvaluator
+
+
+            def objective(trial):
+                x1 = trial.suggest_float("x1", -10, 10)
+                x2 = trial.suggest_float("x2", -10, 10)
+                return x1 + x2 / 1000
+
+
+            study = optuna.create_study()
+            study.optimize(objective, n_trials=100)
+            evaluator = PedAnovaImportanceEvaluator()
+            importance = optuna.importance.get_param_importances(study, evaluator=evaluator)
+
+    """
+
+    def __init__(
+        self,
+        *,
+        baseline_quantile: float = 0.1,
+        evaluate_on_local: bool = True,
+    ):
+        assert 0.0 <= baseline_quantile <= 1.0, "baseline_quantile must be in [0, 1]."
+        self._baseline_quantile = baseline_quantile
+        self._evaluate_on_local = evaluate_on_local
+
+        # Advanced Setups.
+        # Discretize a domain [low, high] as `np.linspace(low, high, n_steps)`.
+        self._n_steps: int = 50
+        # Control the regularization effect by prior.
+        self._prior_weight = 1.0
+        # How many `trials` must be included in `top_trials`.
+        self._min_n_top_trials = 2
+
+    def _get_top_trials(
+        self,
+        study: Study,
+        trials: list[FrozenTrial],
+        params: list[str],
+        target: Callable[[FrozenTrial], float] | None,
+    ) -> list[FrozenTrial]:
+        is_lower_better = study.directions[0] == StudyDirection.MINIMIZE
+        if target is not None:
+            warnings.warn(
+                f"{self.__class__.__name__} computes the importances of params to achieve "
+                "low `target` values. If this is not what you want, "
+                "please modify target, e.g., by multiplying the output by -1."
+            )
+            is_lower_better = True
+
+        top_trials = _QuantileFilter(
+            self._baseline_quantile, is_lower_better, self._min_n_top_trials, target
+        ).filter(trials)
+
+        if len(trials) == len(top_trials):
+            _logger.warning("All trials are in top trials, which gives equal importances.")
+
+        return top_trials
+
+    def _compute_pearson_divergence(
+        self,
+        param_name: str,
+        dist: BaseDistribution,
+        top_trials: list[FrozenTrial],
+        all_trials: list[FrozenTrial],
+    ) -> float:
+        # When pdf_all == pdf_top, i.e. all_trials == top_trials, this method will give 0.0.
+        prior_weight = self._prior_weight
+        pe_top = _build_parzen_estimator(param_name, dist, top_trials, self._n_steps, prior_weight)
+        # NOTE: pe_top.n_steps could be different from self._n_steps.
+        grids = np.arange(pe_top.n_steps)
+        pdf_top = pe_top.pdf(grids) + 1e-12
+
+        if self._evaluate_on_local:  # The importance of param during the study.
+            pe_local = _build_parzen_estimator(
+                param_name, dist, all_trials, self._n_steps, prior_weight
+            )
+            pdf_local = pe_local.pdf(grids) + 1e-12
+        else:  # The importance of param in the search space.
+            pdf_local = np.full(pe_top.n_steps, 1.0 / pe_top.n_steps)
+
+        return float(pdf_local @ ((pdf_top / pdf_local - 1) ** 2))
+
+    def evaluate(
+        self,
+        study: Study,
+        params: list[str] | None = None,
+        *,
+        target: Callable[[FrozenTrial], float] | None = None,
+    ) -> dict[str, float]:
+        dists = _get_distributions(study, params=params)
+        if params is None:
+            params = list(dists.keys())
+
+        assert params is not None
+        # PED-ANOVA does not support parameter distributions with a single value,
+        # because the importance of such params become zero.
+        non_single_dists = {name: dist for name, dist in dists.items() if not dist.single()}
+        single_dists = {name: dist for name, dist in dists.items() if dist.single()}
+        if len(non_single_dists) == 0:
+            return {}
+
+        trials = _get_filtered_trials(study, params=params, target=target)
+        n_params = len(non_single_dists)
+        # The following should be tested at _get_filtered_trials.
+        assert target is not None or max([len(t.values) for t in trials], default=1) == 1
+        if len(trials) <= self._min_n_top_trials:
+            param_importances = {k: 1.0 / n_params for k in non_single_dists}
+            param_importances.update({k: 0.0 for k in single_dists})
+            return {k: 0.0 for k in param_importances}
+
+        top_trials = self._get_top_trials(study, trials, params, target)
+        quantile = len(top_trials) / len(trials)
+        importance_sum = 0.0
+        param_importances = {}
+        for param_name, dist in non_single_dists.items():
+            param_importances[param_name] = quantile * self._compute_pearson_divergence(
+                param_name, dist, top_trials=top_trials, all_trials=trials
+            )
+            importance_sum += param_importances[param_name]
+
+        param_importances.update({k: 0.0 for k in single_dists})
+        return _sort_dict_by_importance(param_importances)

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/importance/_ped_anova/scott_parzen_estimator.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import numpy as np
+
+from optuna.distributions import BaseDistribution
+from optuna.distributions import CategoricalDistribution
+from optuna.distributions import FloatDistribution
+from optuna.distributions import IntDistribution
+from optuna.samplers._tpe.parzen_estimator import _ParzenEstimator
+from optuna.samplers._tpe.parzen_estimator import _ParzenEstimatorParameters
+from optuna.samplers._tpe.probability_distributions import _BatchedDiscreteTruncNormDistributions
+from optuna.samplers._tpe.probability_distributions import _BatchedDistributions
+from optuna.trial import FrozenTrial
+
+
+class _ScottParzenEstimator(_ParzenEstimator):
+    """1D ParzenEstimator using the bandwidth selection by Scott's rule."""
+
+    def __init__(
+        self,
+        param_name: str,
+        dist: IntDistribution | CategoricalDistribution,
+        counts: np.ndarray,
+        prior_weight: float,
+    ):
+        assert isinstance(dist, (CategoricalDistribution, IntDistribution))
+        assert not isinstance(dist, IntDistribution) or dist.low == 0
+        n_choices = dist.high + 1 if isinstance(dist, IntDistribution) else len(dist.choices)
+        assert len(counts) == n_choices, counts
+
+        self._n_steps = len(counts)
+        self._param_name = param_name
+        self._counts = counts.copy()
+        super().__init__(
+            observations={param_name: np.arange(self._n_steps)[counts > 0.0]},
+            search_space={param_name: dist},
+            parameters=_ParzenEstimatorParameters(
+                prior_weight=prior_weight,
+                consider_magic_clip=False,
+                consider_endpoints=False,
+                weights=lambda x: np.empty(0),
+                multivariate=True,
+                categorical_distance_func={},
+            ),
+            predetermined_weights=counts[counts > 0.0],
+        )
+
+    def _calculate_numerical_distributions(
+        self,
+        observations: np.ndarray,
+        low: float,  # The type is actually int, but typing follows the original.
+        high: float,  # The type is actually int, but typing follows the original.
+        step: float | None,
+        parameters: _ParzenEstimatorParameters,
+    ) -> _BatchedDistributions:
+        # NOTE: The Optuna TPE bandwidth selection is too wide for this analysis.
+        # So use the Scott's rule by Scott, D.W. (1992),
+        # Multivariate Density Estimation: Theory, Practice, and Visualization.
+        assert step is not None and np.isclose(step, 1.0), "MyPy redefinition."
+
+        n_trials = np.sum(self._counts)
+        counts_non_zero = self._counts[self._counts > 0]
+        weights = counts_non_zero / n_trials
+        mus = np.arange(self.n_steps)[self._counts > 0]
+        mean_est = mus @ weights
+        sigma_est = np.sqrt((mus - mean_est) ** 2 @ counts_non_zero / max(1, n_trials - 1))
+
+        count_cum = np.cumsum(counts_non_zero)
+        idx_q25 = np.searchsorted(count_cum, n_trials // 4, side="left")
+        idx_q75 = np.searchsorted(count_cum, n_trials * 3 // 4, side="right")
+        interquantile_range = mus[min(mus.size - 1, idx_q75)] - mus[idx_q25]
+        sigma_est = 1.059 * min(interquantile_range / 1.34, sigma_est) * n_trials ** (-0.2)
+        # To avoid numerical errors. 0.5/1.64 means 1.64sigma (=90%) will fit in the target grid.
+        sigma_min = 0.5 / 1.64
+        sigmas = np.full_like(mus, max(sigma_est, sigma_min), dtype=np.float64)
+        mus = np.append(mus, [0.5 * (low + high)])
+        sigmas = np.append(sigmas, [1.0 * (high - low + 1)])
+
+        return _BatchedDiscreteTruncNormDistributions(
+            mu=mus, sigma=sigmas, low=0, high=self.n_steps - 1, step=1
+        )
+
+    @property
+    def n_steps(self) -> int:
+        return self._n_steps
+
+    def pdf(self, samples: np.ndarray) -> np.ndarray:
+        return np.exp(self.log_pdf({self._param_name: samples}))
+
+
+def _get_grids_and_grid_indices_of_trials(
+    param_name: str,
+    dist: IntDistribution | FloatDistribution,
+    trials: list[FrozenTrial],
+    n_steps: int,
+) -> tuple[int, np.ndarray]:
+    assert isinstance(dist, (FloatDistribution, IntDistribution)), "Unexpected distribution."
+    if isinstance(dist, IntDistribution) and dist.log:
+        log2_domain_size = int(np.ceil(np.log(dist.high - dist.low + 1) / np.log(2))) + 1
+        n_steps = min(log2_domain_size, n_steps)
+    elif dist.step is not None:
+        assert not dist.log, "log must be False when step is not None."
+        n_steps = min(round((dist.high - dist.low) / dist.step) + 1, n_steps)
+
+    scaler = np.log if dist.log else np.asarray
+    grids = np.linspace(scaler(dist.low), scaler(dist.high), n_steps)
+    params = scaler([t.params[param_name] for t in trials])
+    step_size = grids[1] - grids[0]
+    # grids[indices[n] - 1] < param - step_size / 2 <= grids[indices[n]]
+    indices = np.searchsorted(grids, params - step_size / 2)
+    return grids.size, indices
+
+
+def _count_numerical_param_in_grid(
+    param_name: str,
+    dist: IntDistribution | FloatDistribution,
+    trials: list[FrozenTrial],
+    n_steps: int,
+) -> np.ndarray:
+    n_grids, grid_indices_of_trials = _get_grids_and_grid_indices_of_trials(
+        param_name, dist, trials, n_steps
+    )
+    unique_vals, counts_in_unique = np.unique(grid_indices_of_trials, return_counts=True)
+    counts = np.zeros(n_grids, dtype=np.int32)
+    counts[unique_vals] += counts_in_unique
+    return counts
+
+
+def _count_categorical_param_in_grid(
+    param_name: str, dist: CategoricalDistribution, trials: list[FrozenTrial]
+) -> np.ndarray:
+    cat_indices = [int(dist.to_internal_repr(t.params[param_name])) for t in trials]
+    unique_vals, counts_in_unique = np.unique(cat_indices, return_counts=True)
+    counts = np.zeros(len(dist.choices), dtype=np.int32)
+    counts[unique_vals] += counts_in_unique
+    return counts
+
+
+def _build_parzen_estimator(
+    param_name: str,
+    dist: BaseDistribution,
+    trials: list[FrozenTrial],
+    n_steps: int,
+    prior_weight: float,
+) -> _ScottParzenEstimator:
+    rounded_dist: IntDistribution | CategoricalDistribution
+    if isinstance(dist, (IntDistribution, FloatDistribution)):
+        counts = _count_numerical_param_in_grid(param_name, dist, trials, n_steps)
+        rounded_dist = IntDistribution(low=0, high=counts.size - 1)
+    elif isinstance(dist, CategoricalDistribution):
+        counts = _count_categorical_param_in_grid(param_name, dist, trials)
+        rounded_dist = dist
+    else:
+        assert False, f"Got an unknown dist with the type {type(dist)}."
+
+    # counts.astype(float) is necessary for weight calculation in ParzenEstimator.
+    return _ScottParzenEstimator(param_name, rounded_dist, counts.astype(np.float64), prior_weight)

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/search_space/__init__.py

@@ -0,0 +1,12 @@
+from optuna.search_space.group_decomposed import _GroupDecomposedSearchSpace
+from optuna.search_space.group_decomposed import _SearchSpaceGroup
+from optuna.search_space.intersection import intersection_search_space
+from optuna.search_space.intersection import IntersectionSearchSpace
+
+
+__all__ = [
+    "_GroupDecomposedSearchSpace",
+    "_SearchSpaceGroup",
+    "IntersectionSearchSpace",
+    "intersection_search_space",
+]

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/__init__.py

@@ -0,0 +1,28 @@
+from optuna.terminator.callback import TerminatorCallback
+from optuna.terminator.erroreval import BaseErrorEvaluator
+from optuna.terminator.erroreval import CrossValidationErrorEvaluator
+from optuna.terminator.erroreval import report_cross_validation_scores
+from optuna.terminator.erroreval import StaticErrorEvaluator
+from optuna.terminator.improvement.emmr import EMMREvaluator
+from optuna.terminator.improvement.evaluator import BaseImprovementEvaluator
+from optuna.terminator.improvement.evaluator import BestValueStagnationEvaluator
+from optuna.terminator.improvement.evaluator import RegretBoundEvaluator
+from optuna.terminator.median_erroreval import MedianErrorEvaluator
+from optuna.terminator.terminator import BaseTerminator
+from optuna.terminator.terminator import Terminator
+
+
+__all__ = [
+    "TerminatorCallback",
+    "BaseErrorEvaluator",
+    "CrossValidationErrorEvaluator",
+    "report_cross_validation_scores",
+    "StaticErrorEvaluator",
+    "MedianErrorEvaluator",
+    "BaseImprovementEvaluator",
+    "BestValueStagnationEvaluator",
+    "RegretBoundEvaluator",
+    "EMMREvaluator",
+    "BaseTerminator",
+    "Terminator",
+]

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/callback.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from optuna._experimental import experimental_class
+from optuna.logging import get_logger
+from optuna.study.study import Study
+from optuna.terminator.terminator import BaseTerminator
+from optuna.terminator.terminator import Terminator
+from optuna.trial import FrozenTrial
+
+
+_logger = get_logger(__name__)
+
+
+@experimental_class("3.2.0")
+class TerminatorCallback:
+    """A callback that terminates the optimization using Terminator.
+
+    This class implements a callback which wraps :class:`~optuna.terminator.Terminator`
+    so that it can be used with the :func:`~optuna.study.Study.optimize` method.
+
+    Args:
+        terminator:
+            A terminator object which determines whether to terminate the optimization by
+            assessing the room for optimization and statistical error. Defaults to a
+            :class:`~optuna.terminator.Terminator` object with default
+            ``improvement_evaluator`` and ``error_evaluator``.
+
+    Example:
+
+        .. testcode::
+
+            from sklearn.datasets import load_wine
+            from sklearn.ensemble import RandomForestClassifier
+            from sklearn.model_selection import cross_val_score
+            from sklearn.model_selection import KFold
+
+            import optuna
+            from optuna.terminator import TerminatorCallback
+            from optuna.terminator import report_cross_validation_scores
+
+
+            def objective(trial):
+                X, y = load_wine(return_X_y=True)
+
+                clf = RandomForestClassifier(
+                    max_depth=trial.suggest_int("max_depth", 2, 32),
+                    min_samples_split=trial.suggest_float("min_samples_split", 0, 1),
+                    criterion=trial.suggest_categorical("criterion", ("gini", "entropy")),
+                )
+
+                scores = cross_val_score(clf, X, y, cv=KFold(n_splits=5, shuffle=True))
+                report_cross_validation_scores(trial, scores)
+                return scores.mean()
+
+
+            study = optuna.create_study(direction="maximize")
+            terminator = TerminatorCallback()
+            study.optimize(objective, n_trials=50, callbacks=[terminator])
+
+    .. seealso::
+        Please refer to :class:`~optuna.terminator.Terminator` for the details of
+        the terminator mechanism.
+    """
+
+    def __init__(self, terminator: BaseTerminator | None = None) -> None:
+        self._terminator = terminator or Terminator()
+
+    def __call__(self, study: Study, trial: FrozenTrial) -> None:
+        should_terminate = self._terminator.should_terminate(study=study)
+
+        if should_terminate:
+            _logger.info("The study has been stopped by the terminator.")
+            study.stop()

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/erroreval.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import abc
+from typing import cast
+
+import numpy as np
+
+from optuna._experimental import experimental_class
+from optuna.study import StudyDirection
+from optuna.trial import FrozenTrial
+from optuna.trial import Trial
+from optuna.trial._state import TrialState
+
+
+_CROSS_VALIDATION_SCORES_KEY = "terminator:cv_scores"
+
+
+class BaseErrorEvaluator(metaclass=abc.ABCMeta):
+    """Base class for error evaluators."""
+
+    @abc.abstractmethod
+    def evaluate(
+        self,
+        trials: list[FrozenTrial],
+        study_direction: StudyDirection,
+    ) -> float:
+        pass
+
+
+@experimental_class("3.2.0")
+class CrossValidationErrorEvaluator(BaseErrorEvaluator):
+    """An error evaluator for objective functions based on cross-validation.
+
+    This evaluator evaluates the objective function's statistical error, which comes from the
+    randomness of dataset. This evaluator assumes that the objective function is the average of
+    the cross-validation and uses the scaled variance of the cross-validation scores in the best
+    trial at the moment as the statistical error.
+
+    """
+
+    def evaluate(
+        self,
+        trials: list[FrozenTrial],
+        study_direction: StudyDirection,
+    ) -> float:
+        """Evaluate the statistical error of the objective function based on cross-validation.
+
+        Args:
+            trials:
+                A list of trials to consider. The best trial in ``trials`` is used to compute the
+                statistical error.
+
+            study_direction:
+                The direction of the study.
+
+        Returns:
+            A float representing the statistical error of the objective function.
+
+        """
+        trials = [trial for trial in trials if trial.state == TrialState.COMPLETE]
+        assert len(trials) > 0
+
+        if study_direction == StudyDirection.MAXIMIZE:
+            best_trial = max(trials, key=lambda t: cast(float, t.value))
+        else:
+            best_trial = min(trials, key=lambda t: cast(float, t.value))
+
+        best_trial_attrs = best_trial.system_attrs
+        if _CROSS_VALIDATION_SCORES_KEY in best_trial_attrs:
+            cv_scores = best_trial_attrs[_CROSS_VALIDATION_SCORES_KEY]
+        else:
+            raise ValueError(
+                "Cross-validation scores have not been reported. Please call "
+                "`report_cross_validation_scores(trial, scores)` during a trial and pass the "
+                "list of scores as `scores`."
+            )
+
+        k = len(cv_scores)
+        assert k > 1, "Should be guaranteed by `report_cross_validation_scores`."
+        scale = 1 / k + 1 / (k - 1)
+
+        var = scale * np.var(cv_scores)
+        std = np.sqrt(var)
+
+        return float(std)
+
+
+@experimental_class("3.2.0")
+def report_cross_validation_scores(trial: Trial, scores: list[float]) -> None:
+    """A function to report cross-validation scores of a trial.
+
+    This function should be called within the objective function to report the cross-validation
+    scores. The reported scores are used to evaluate the statistical error for termination
+    judgement.
+
+    Args:
+        trial:
+            A :class:`~optuna.trial.Trial` object to report the cross-validation scores.
+        scores:
+            The cross-validation scores of the trial.
+
+    """
+    if len(scores) <= 1:
+        raise ValueError("The length of `scores` is expected to be greater than one.")
+    trial.storage.set_trial_system_attr(trial._trial_id, _CROSS_VALIDATION_SCORES_KEY, scores)
+
+
+@experimental_class("3.2.0")
+class StaticErrorEvaluator(BaseErrorEvaluator):
+    """An error evaluator that always returns a constant value.
+
+    This evaluator can be used to terminate the optimization when the evaluated improvement
+    potential is below the fixed threshold.
+
+    Args:
+        constant:
+            A user-specified constant value to always return as an error estimate.
+
+    """
+
+    def __init__(self, constant: float) -> None:
+        self._constant = constant
+
+    def evaluate(
+        self,
+        trials: list[FrozenTrial],
+        study_direction: StudyDirection,
+    ) -> float:
+        return self._constant

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/improvement/emmr.py

@@ -0,0 +1,354 @@
+from __future__ import annotations
+
+import math
+import sys
+from typing import cast
+from typing import TYPE_CHECKING
+import warnings
+
+import numpy as np
+
+from optuna._experimental import experimental_class
+from optuna.samplers._lazy_random_state import LazyRandomState
+from optuna.search_space import intersection_search_space
+from optuna.study import StudyDirection
+from optuna.terminator.improvement.evaluator import _compute_standardized_regret_bound
+from optuna.terminator.improvement.evaluator import BaseImprovementEvaluator
+from optuna.trial import FrozenTrial
+from optuna.trial import TrialState
+
+
+if TYPE_CHECKING:
+    import scipy.stats as scipy_stats
+    import torch
+
+    from optuna._gp import acqf as acqf_module
+    from optuna._gp import gp
+    from optuna._gp import prior
+    from optuna._gp import search_space as gp_search_space
+else:
+    from optuna._imports import _LazyImport
+
+    torch = _LazyImport("torch")
+    gp = _LazyImport("optuna._gp.gp")
+    acqf_module = _LazyImport("optuna._gp.acqf")
+    prior = _LazyImport("optuna._gp.prior")
+    gp_search_space = _LazyImport("optuna._gp.search_space")
+    scipy_stats = _LazyImport("scipy.stats")
+
+MARGIN_FOR_NUMARICAL_STABILITY = 0.1
+
+
+@experimental_class("4.0.0")
+class EMMREvaluator(BaseImprovementEvaluator):
+    """Evaluates a kind of regrets, called the Expected Minimum Model Regret(EMMR).
+
+    EMMR is an upper bound of "expected minimum simple regret" in the optimization process.
+
+    Expected minimum simple regret is a quantity that converges to zero only if the
+    optimization process has found the global optima.
+
+    For further information about expected minimum simple regret and the algorithm,
+    please refer to the following paper:
+
+    - `A stopping criterion for Bayesian optimization by the gap of expected minimum simple
+      regrets <https://proceedings.mlr.press/v206/ishibashi23a.html>`__
+
+    Also, there is our blog post explaining this evaluator:
+
+    - `Introducing A New Terminator: Early Termination of Black-box Optimization Based on
+      Expected Minimum Model Regret
+      <https://medium.com/optuna/introducing-a-new-terminator-early-termination-of-black-box-optimization-based-on-expected-9a660774fcdb>`__
+
+    Args:
+        deterministic_objective:
+            A boolean value which indicates whether the objective function is deterministic.
+            Default is :obj:`False`.
+        delta:
+            A float number related to the criterion for termination. Default to 0.1.
+            For further information about this parameter, please see the aforementioned paper.
+        min_n_trials:
+            A minimum number of complete trials to compute the criterion. Default to 2.
+        seed:
+            A random seed for EMMREvaluator.
+
+    Example:
+
+        .. testcode::
+
+            import optuna
+            from optuna.terminator import EMMREvaluator
+            from optuna.terminator import MedianErrorEvaluator
+            from optuna.terminator import Terminator
+
+            sampler = optuna.samplers.TPESampler(seed=0)
+            study = optuna.create_study(sampler=sampler, direction="minimize")
+            emmr_improvement_evaluator = EMMREvaluator()
+            median_error_evaluator = MedianErrorEvaluator(emmr_improvement_evaluator)
+            terminator = Terminator(
+                improvement_evaluator=emmr_improvement_evaluator,
+                error_evaluator=median_error_evaluator,
+            )
+
+
+            for i in range(1000):
+                trial = study.ask()
+
+                ys = [trial.suggest_float(f"x{i}", -10.0, 10.0) for i in range(5)]
+                value = sum(ys[i] ** 2 for i in range(5))
+
+                study.tell(trial, value)
+
+                if terminator.should_terminate(study):
+                    # Terminated by Optuna Terminator!
+                    break
+
+    """
+
+    def __init__(
+        self,
+        deterministic_objective: bool = False,
+        delta: float = 0.1,
+        min_n_trials: int = 2,
+        seed: int | None = None,
+    ) -> None:
+        if min_n_trials <= 1 or not np.isfinite(min_n_trials):
+            raise ValueError("`min_n_trials` is expected to be a finite integer more than one.")
+
+        self._deterministic = deterministic_objective
+        self._delta = delta
+        self.min_n_trials = min_n_trials
+        self._rng = LazyRandomState(seed)
+
+    def evaluate(self, trials: list[FrozenTrial], study_direction: StudyDirection) -> float:
+
+        optuna_search_space = intersection_search_space(trials)
+        complete_trials = [t for t in trials if t.state == TrialState.COMPLETE]
+
+        if len(complete_trials) < self.min_n_trials:
+            return sys.float_info.max * MARGIN_FOR_NUMARICAL_STABILITY  # Do not terminate.
+
+        search_space = gp_search_space.SearchSpace(optuna_search_space)
+        normalized_params = search_space.get_normalized_params(complete_trials)
+        if not search_space.dim:
+            warnings.warn(
+                f"{self.__class__.__name__} cannot consider any search space."
+                "Termination will never occur in this study."
+            )
+            return sys.float_info.max * MARGIN_FOR_NUMARICAL_STABILITY  # Do not terminate.
+
+        len_trials = len(complete_trials)
+        assert normalized_params.shape == (len_trials, search_space.dim)
+
+        # _gp module assumes that optimization direction is maximization
+        sign = -1 if study_direction == StudyDirection.MINIMIZE else 1
+        score_vals = np.array([cast(float, t.value) for t in complete_trials]) * sign
+        score_vals = gp.warn_and_convert_inf(score_vals)
+        standarized_score_vals = (score_vals - score_vals.mean()) / max(
+            sys.float_info.min, score_vals.std()
+        )
+
+        assert len(standarized_score_vals) == len(normalized_params)
+
+        gpr_t1 = gp.fit_kernel_params(  # Fit kernel with up to (t-1)-th observation
+            X=normalized_params[..., :-1, :],
+            Y=standarized_score_vals[:-1],
+            is_categorical=search_space.is_categorical,
+            log_prior=prior.default_log_prior,
+            minimum_noise=prior.DEFAULT_MINIMUM_NOISE_VAR,
+            gpr_cache=None,
+            deterministic_objective=self._deterministic,
+        )
+
+        gpr_t = gp.fit_kernel_params(  # Fit kernel with up to t-th observation
+            X=normalized_params,
+            Y=standarized_score_vals,
+            is_categorical=search_space.is_categorical,
+            log_prior=prior.default_log_prior,
+            minimum_noise=prior.DEFAULT_MINIMUM_NOISE_VAR,
+            gpr_cache=gpr_t1,
+            deterministic_objective=self._deterministic,
+        )
+
+        theta_t_star_index = int(np.argmax(standarized_score_vals))
+        theta_t1_star_index = int(np.argmax(standarized_score_vals[:-1]))
+        theta_t_star = normalized_params[theta_t_star_index, :]
+        theta_t1_star = normalized_params[theta_t1_star_index, :]
+
+        cov_t_between_theta_t_star_and_theta_t1_star = _compute_gp_posterior_cov_two_thetas(
+            search_space,
+            normalized_params,
+            standarized_score_vals,
+            gpr_t,
+            theta_t_star_index,
+            theta_t1_star_index,
+        )
+
+        mu_t1_theta_t_with_nu_t, variance_t1_theta_t_with_nu_t = _compute_gp_posterior(
+            search_space,
+            normalized_params[:-1, :],
+            standarized_score_vals[:-1],
+            normalized_params[-1, :],
+            gpr_t,
+            # Use gpr_t instead of gpr_t1.
+            # Use "t" under the assumption that "t" and "t1" are approximately the same.
+            # This is because kernel should same when computing KLD.
+            # For detailed information, please see section 4.4 of the paper:
+            # https://proceedings.mlr.press/v206/ishibashi23a/ishibashi23a.pdf
+        )
+        _, variance_t_theta_t1_star = _compute_gp_posterior(
+            search_space,
+            normalized_params,
+            standarized_score_vals,
+            theta_t1_star,
+            gpr_t,
+        )
+        mu_t_theta_t_star, variance_t_theta_t_star = _compute_gp_posterior(
+            search_space,
+            normalized_params,
+            standarized_score_vals,
+            theta_t_star,
+            gpr_t,
+        )
+        mu_t1_theta_t1_star, _ = _compute_gp_posterior(
+            search_space,
+            normalized_params[:-1, :],
+            standarized_score_vals[:-1],
+            theta_t1_star,
+            gpr_t1,
+        )
+
+        y_t = standarized_score_vals[-1]
+        kappa_t1 = _compute_standardized_regret_bound(
+            gpr_t1,
+            search_space,
+            normalized_params[:-1, :],
+            standarized_score_vals[:-1],
+            self._delta,
+            rng=self._rng.rng,
+        )
+
+        theorem1_delta_mu_t_star = mu_t1_theta_t1_star - mu_t_theta_t_star
+
+        alg1_delta_r_tilde_t_term1 = theorem1_delta_mu_t_star
+
+        theorem1_v = math.sqrt(
+            max(
+                1e-10,
+                variance_t_theta_t_star
+                - 2.0 * cov_t_between_theta_t_star_and_theta_t1_star
+                + variance_t_theta_t1_star,
+            )
+        )
+        theorem1_g = (mu_t_theta_t_star - mu_t1_theta_t1_star) / theorem1_v
+
+        alg1_delta_r_tilde_t_term2 = theorem1_v * scipy_stats.norm.pdf(theorem1_g)
+        alg1_delta_r_tilde_t_term3 = theorem1_v * theorem1_g * scipy_stats.norm.cdf(theorem1_g)
+
+        _lambda = prior.DEFAULT_MINIMUM_NOISE_VAR**-1
+        eq4_rhs_term1 = 0.5 * math.log(1.0 + _lambda * variance_t1_theta_t_with_nu_t)
+        eq4_rhs_term2 = (
+            -0.5 * variance_t1_theta_t_with_nu_t / (variance_t1_theta_t_with_nu_t + _lambda**-1)
+        )
+        eq4_rhs_term3 = (
+            0.5
+            * variance_t1_theta_t_with_nu_t
+            * (y_t - mu_t1_theta_t_with_nu_t) ** 2
+            / (variance_t1_theta_t_with_nu_t + _lambda**-1) ** 2
+        )
+
+        alg1_delta_r_tilde_t_term4 = kappa_t1 * math.sqrt(
+            0.5 * (eq4_rhs_term1 + eq4_rhs_term2 + eq4_rhs_term3)
+        )
+
+        return min(
+            sys.float_info.max * 0.5,
+            alg1_delta_r_tilde_t_term1
+            + alg1_delta_r_tilde_t_term2
+            + alg1_delta_r_tilde_t_term3
+            + alg1_delta_r_tilde_t_term4,
+        )
+
+
+def _compute_gp_posterior(
+    search_space: gp_search_space.SearchSpace,
+    X: np.ndarray,
+    Y: np.ndarray,
+    x_params: np.ndarray,
+    gpr: gp.GPRegressor,
+) -> tuple[float, float]:  # mean, var
+    mean_tensor, var_tensor = gpr.posterior(
+        torch.from_numpy(x_params),  # best_params or normalized_params[..., -1, :]),
+    )
+    mean = mean_tensor.detach().numpy().flatten()
+    var = var_tensor.detach().numpy().flatten()
+    assert len(mean) == 1 and len(var) == 1
+    return float(mean[0]), float(var[0])
+
+
+def _posterior_of_batched_theta(
+    gpr: gp.GPRegressor,
+    X: torch.Tensor,  # [len(trials), len(params)]
+    cov_Y_Y_inv: torch.Tensor,  # [len(trials), len(trials)]
+    cov_Y_Y_inv_Y: torch.Tensor,  # [len(trials)]
+    theta: torch.Tensor,  # [batch, len(params)]
+) -> tuple[torch.Tensor, torch.Tensor]:  # (mean: [(batch,)], var: [(batch,batch)])
+
+    assert len(X.shape) == 2
+    len_trials, len_params = X.shape
+    assert len(theta.shape) == 2
+    len_batch = theta.shape[0]
+    assert theta.shape == (len_batch, len_params)
+    assert cov_Y_Y_inv.shape == (len_trials, len_trials)
+    assert cov_Y_Y_inv_Y.shape == (len_trials,)
+
+    cov_ftheta_fX = gpr.kernel(theta[..., None, :], X)[..., 0, :]
+    assert cov_ftheta_fX.shape == (len_batch, len_trials)
+    cov_ftheta_ftheta = gpr.kernel(theta[..., None, :], theta)[..., 0, :]
+    assert cov_ftheta_ftheta.shape == (len_batch, len_batch)
+
+    assert torch.allclose(cov_ftheta_ftheta.diag(), gpr.kernel_scale)
+    assert torch.allclose(cov_ftheta_ftheta, cov_ftheta_ftheta.T)
+
+    mean = cov_ftheta_fX @ cov_Y_Y_inv_Y
+    assert mean.shape == (len_batch,)
+    var = cov_ftheta_ftheta - cov_ftheta_fX @ cov_Y_Y_inv @ cov_ftheta_fX.T
+    assert var.shape == (len_batch, len_batch)
+
+    # We need to clamp the variance to avoid negative values due to numerical errors.
+    return mean, torch.clamp(var, min=0.0)
+
+
+def _compute_gp_posterior_cov_two_thetas(
+    search_space: gp_search_space.SearchSpace,
+    normalized_params: np.ndarray,
+    standarized_score_vals: np.ndarray,
+    gpr: gp.GPRegressor,
+    theta1_index: int,
+    theta2_index: int,
+) -> float:  # cov
+
+    if theta1_index == theta2_index:
+        return _compute_gp_posterior(
+            search_space,
+            normalized_params,
+            standarized_score_vals,
+            normalized_params[theta1_index],
+            gpr,
+        )[1]
+
+    assert normalized_params.shape[0] == standarized_score_vals.shape[0]
+
+    cov_Y_Y_inv = gpr._cov_Y_Y_inv
+    cov_Y_Y_inv_Y = gpr._cov_Y_Y_inv_Y
+    assert cov_Y_Y_inv is not None and cov_Y_Y_inv_Y is not None
+    _, var = _posterior_of_batched_theta(
+        gpr,
+        gpr._X_train,
+        cov_Y_Y_inv,
+        cov_Y_Y_inv_Y,
+        torch.from_numpy(normalized_params[[theta1_index, theta2_index]]),
+    )
+    assert var.shape == (2, 2)
+    var = var.detach().numpy()[0, 1]
+    return float(var)

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/improvement/evaluator.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import abc
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from optuna._experimental import experimental_class
+from optuna.distributions import BaseDistribution
+from optuna.samplers._lazy_random_state import LazyRandomState
+from optuna.search_space import intersection_search_space
+from optuna.study import StudyDirection
+from optuna.trial import FrozenTrial
+from optuna.trial import TrialState
+
+
+if TYPE_CHECKING:
+
+    from optuna._gp import acqf as acqf_module
+    from optuna._gp import gp
+    from optuna._gp import optim_sample
+    from optuna._gp import prior
+    from optuna._gp import search_space as gp_search_space
+else:
+    from optuna._imports import _LazyImport
+
+    gp = _LazyImport("optuna._gp.gp")
+    optim_sample = _LazyImport("optuna._gp.optim_sample")
+    acqf_module = _LazyImport("optuna._gp.acqf")
+    prior = _LazyImport("optuna._gp.prior")
+    gp_search_space = _LazyImport("optuna._gp.search_space")
+
+DEFAULT_TOP_TRIALS_RATIO = 0.5
+DEFAULT_MIN_N_TRIALS = 20
+
+
+def _get_beta(n_params: int, n_trials: int, delta: float = 0.1) -> float:
+    # TODO(nabenabe0928): Check the original implementation to verify.
+    # Especially, |D| seems to be the domain size, but not the dimension based on Theorem 1.
+    beta = 2 * np.log(n_params * n_trials**2 * np.pi**2 / 6 / delta)
+
+    # The following div is according to the original paper: "We then further scale it down
+    # by a factor of 5 as defined in the experiments in
+    # `Srinivas et al. (2010) <https://dl.acm.org/doi/10.5555/3104322.3104451>`__"
+    beta /= 5
+
+    return beta
+
+
+def _compute_standardized_regret_bound(
+    gpr: gp.GPRegressor,
+    search_space: gp_search_space.SearchSpace,
+    normalized_top_n_params: np.ndarray,
+    standarized_top_n_values: np.ndarray,
+    delta: float = 0.1,
+    optimize_n_samples: int = 2048,
+    rng: np.random.RandomState | None = None,
+) -> float:
+    """
+    # In the original paper, f(x) was intended to be minimized, but here we would like to
+    # maximize f(x). Hence, the following changes happen:
+    #     1. min(ucb) over top trials becomes max(lcb) over top trials, and
+    #     2. min(lcb) over the search space becomes max(ucb) over the search space, and
+    #     3. Regret bound becomes max(ucb) over the search space minus max(lcb) over top trials.
+    """
+
+    n_trials, n_params = normalized_top_n_params.shape
+
+    # calculate max_ucb
+    beta = _get_beta(n_params, n_trials, delta)
+    ucb_acqf = acqf_module.UCB(gpr, search_space, beta)
+    # UCB over the search space. (Original: LCB over the search space. See Change 1 above.)
+    standardized_ucb_value = max(
+        ucb_acqf.eval_acqf_no_grad(normalized_top_n_params).max(),
+        optim_sample.optimize_acqf_sample(ucb_acqf, n_samples=optimize_n_samples, rng=rng)[1],
+    )
+
+    # calculate min_lcb
+    lcb_acqf = acqf_module.LCB(gpr=gpr, search_space=search_space, beta=beta)
+    # LCB over the top trials. (Original: UCB over the top trials. See Change 2 above.)
+    standardized_lcb_value = np.max(lcb_acqf.eval_acqf_no_grad(normalized_top_n_params))
+
+    # max(UCB) - max(LCB). (Original: min(UCB) - min(LCB). See Change 3 above.)
+    return standardized_ucb_value - standardized_lcb_value  # standardized regret bound
+
+
+@experimental_class("3.2.0")
+class BaseImprovementEvaluator(metaclass=abc.ABCMeta):
+    """Base class for improvement evaluators."""
+
+    @abc.abstractmethod
+    def evaluate(self, trials: list[FrozenTrial], study_direction: StudyDirection) -> float:
+        pass
+
+
+@experimental_class("3.2.0")
+class RegretBoundEvaluator(BaseImprovementEvaluator):
+    """An error evaluator for upper bound on the regret with high-probability confidence.
+
+    This evaluator evaluates the regret of current best solution, which defined as the difference
+    between the objective value of the best solution and of the global optimum. To be specific,
+    this evaluator calculates the upper bound on the regret based on the fact that empirical
+    estimator of the objective function is bounded by lower and upper confidence bounds with
+    high probability under the Gaussian process model assumption.
+
+    Args:
+        top_trials_ratio:
+            A ratio of top trials to be considered when estimating the regret. Default to 0.5.
+        min_n_trials:
+            A minimum number of complete trials to estimate the regret. Default to 20.
+        seed:
+            Seed for random number generator.
+
+    For further information about this evaluator, please refer to the following paper:
+
+    - `Automatic Termination for Hyperparameter Optimization <https://proceedings.mlr.press/v188/makarova22a.html>`__
+    """  # NOQA: E501
+
+    def __init__(
+        self,
+        top_trials_ratio: float = DEFAULT_TOP_TRIALS_RATIO,
+        min_n_trials: int = DEFAULT_MIN_N_TRIALS,
+        seed: int | None = None,
+    ) -> None:
+        self._top_trials_ratio = top_trials_ratio
+        self._min_n_trials = min_n_trials
+        self._log_prior = prior.default_log_prior
+        self._minimum_noise = prior.DEFAULT_MINIMUM_NOISE_VAR
+        self._optimize_n_samples = 2048
+        self._rng = LazyRandomState(seed)
+
+    def _get_top_n(
+        self, normalized_params: np.ndarray, values: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+        assert len(normalized_params) == len(values)
+        n_trials = len(normalized_params)
+        top_n = np.clip(int(n_trials * self._top_trials_ratio), self._min_n_trials, n_trials)
+        top_n_val = np.partition(values, n_trials - top_n)[n_trials - top_n]
+        top_n_mask = values >= top_n_val
+        return normalized_params[top_n_mask], values[top_n_mask]
+
+    def evaluate(self, trials: list[FrozenTrial], study_direction: StudyDirection) -> float:
+        optuna_search_space = intersection_search_space(trials)
+        self._validate_input(trials, optuna_search_space)
+
+        complete_trials = [t for t in trials if t.state == TrialState.COMPLETE]
+
+        # _gp module assumes that optimization direction is maximization
+        sign = -1 if study_direction == StudyDirection.MINIMIZE else 1
+        values = np.array([t.value for t in complete_trials]) * sign
+        search_space = gp_search_space.SearchSpace(optuna_search_space)
+        normalized_params = search_space.get_normalized_params(complete_trials)
+        normalized_top_n_params, top_n_values = self._get_top_n(normalized_params, values)
+        top_n_values_mean = top_n_values.mean()
+        top_n_values_std = max(1e-10, top_n_values.std())
+        standarized_top_n_values = (top_n_values - top_n_values_mean) / top_n_values_std
+
+        gpr = gp.fit_kernel_params(
+            X=normalized_top_n_params,
+            Y=standarized_top_n_values,
+            is_categorical=search_space.is_categorical,
+            log_prior=self._log_prior,
+            minimum_noise=self._minimum_noise,
+            # TODO(contramundum53): Add option to specify this.
+            deterministic_objective=False,
+            # TODO(y0z): Add `kernel_params_cache` to speedup.
+            gpr_cache=None,
+        )
+
+        standardized_regret_bound = _compute_standardized_regret_bound(
+            gpr,
+            search_space,
+            normalized_top_n_params,
+            standarized_top_n_values,
+            rng=self._rng.rng,
+        )
+        return standardized_regret_bound * top_n_values_std  # regret bound
+
+    @classmethod
+    def _validate_input(
+        cls, trials: list[FrozenTrial], search_space: dict[str, BaseDistribution]
+    ) -> None:
+        if len([t for t in trials if t.state == TrialState.COMPLETE]) == 0:
+            raise ValueError(
+                "Because no trial has been completed yet, the regret bound cannot be evaluated."
+            )
+
+        if len(search_space) == 0:
+            raise ValueError(
+                "The intersection search space is empty. This condition is not supported by "
+                f"{cls.__name__}."
+            )
+
+
+@experimental_class("3.4.0")
+class BestValueStagnationEvaluator(BaseImprovementEvaluator):
+    """Evaluates the stagnation period of the best value in an optimization process.
+
+    This class is initialized with a maximum stagnation period (``max_stagnation_trials``)
+    and is designed to evaluate the remaining trials before reaching this maximum period
+    of allowed stagnation. If this remaining trials reach zero, the trial terminates.
+    Therefore, the default error evaluator is instantiated by ``StaticErrorEvaluator(const=0)``.
+
+    Args:
+        max_stagnation_trials:
+            The maximum number of trials allowed for stagnation.
+    """
+
+    def __init__(self, max_stagnation_trials: int = 30) -> None:
+        if max_stagnation_trials < 0:
+            raise ValueError("The maximum number of stagnant trials must not be negative.")
+        self._max_stagnation_trials = max_stagnation_trials
+
+    def evaluate(self, trials: list[FrozenTrial], study_direction: StudyDirection) -> float:
+        self._validate_input(trials)
+        is_maximize_direction = True if (study_direction == StudyDirection.MAXIMIZE) else False
+        trials = [t for t in trials if t.state == TrialState.COMPLETE]
+        current_step = len(trials) - 1
+
+        best_step = 0
+        for i, trial in enumerate(trials):
+            best_value = trials[best_step].value
+            current_value = trial.value
+            assert best_value is not None
+            assert current_value is not None
+            if is_maximize_direction and (best_value < current_value):
+                best_step = i
+            elif (not is_maximize_direction) and (best_value > current_value):
+                best_step = i
+
+        return self._max_stagnation_trials - (current_step - best_step)
+
+    @classmethod
+    def _validate_input(cls, trials: list[FrozenTrial]) -> None:
+        if len([t for t in trials if t.state == TrialState.COMPLETE]) == 0:
+            raise ValueError(
+                "Because no trial has been completed yet, the improvement cannot be evaluated."
+            )

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/median_erroreval.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import sys
+
+import numpy as np
+
+from optuna._experimental import experimental_class
+from optuna.study import StudyDirection
+from optuna.terminator.erroreval import BaseErrorEvaluator
+from optuna.terminator.improvement.evaluator import BaseImprovementEvaluator
+from optuna.trial import FrozenTrial
+from optuna.trial._state import TrialState
+
+
+@experimental_class("4.0.0")
+class MedianErrorEvaluator(BaseErrorEvaluator):
+    """An error evaluator that returns the ratio to initial median.
+
+    This error evaluator is introduced as a heuristics in the following paper:
+
+    - `A stopping criterion for Bayesian optimization by the gap of expected minimum simple
+      regrets <https://proceedings.mlr.press/v206/ishibashi23a.html>`__
+
+    Args:
+        paired_improvement_evaluator:
+            The ``improvement_evaluator`` instance which is set with this ``error_evaluator``.
+        warm_up_trials:
+            A parameter specifies the number of initial trials to be discarded before
+            the calculation of median. Default to 10.
+            In optuna, the first 10 trials are often random sampling.
+            The ``warm_up_trials`` can exclude them from the calculation.
+        n_initial_trials:
+            A parameter specifies the number of initial trials considered in the calculation of
+            median after ``warm_up_trials``. Default to 20.
+        threshold_ratio:
+            A parameter specifies the ratio between the threshold and initial median.
+            Default to 0.01.
+    """
+
+    def __init__(
+        self,
+        paired_improvement_evaluator: BaseImprovementEvaluator,
+        warm_up_trials: int = 10,
+        n_initial_trials: int = 20,
+        threshold_ratio: float = 0.01,
+    ) -> None:
+        if warm_up_trials < 0:
+            raise ValueError("`warm_up_trials` is expected to be a non-negative integer.")
+        if n_initial_trials <= 0:
+            raise ValueError("`n_initial_trials` is expected to be a positive integer.")
+        if threshold_ratio <= 0.0 or not np.isfinite(threshold_ratio):
+            raise ValueError("`threshold_ratio_to_initial_median` is expected to be a positive.")
+
+        self._paired_improvement_evaluator = paired_improvement_evaluator
+        self._warm_up_trials = warm_up_trials
+        self._n_initial_trials = n_initial_trials
+        self._threshold_ratio = threshold_ratio
+        self._threshold: float | None = None
+
+    def evaluate(
+        self,
+        trials: list[FrozenTrial],
+        study_direction: StudyDirection,
+    ) -> float:
+
+        if self._threshold is not None:
+            return self._threshold
+
+        trials = [trial for trial in trials if trial.state == TrialState.COMPLETE]
+        if len(trials) < (self._warm_up_trials + self._n_initial_trials):
+            return (
+                -sys.float_info.min
+            )  # Do not terminate. It assumes that improvement must non-negative.
+        trials.sort(key=lambda trial: trial.number)
+        criteria = []
+        for i in range(1, self._n_initial_trials + 1):
+            criteria.append(
+                self._paired_improvement_evaluator.evaluate(
+                    trials[self._warm_up_trials : self._warm_up_trials + i], study_direction
+                )
+            )
+        criteria.sort()
+        self._threshold = criteria[len(criteria) // 2]
+        assert self._threshold is not None
+        self._threshold = min(sys.float_info.max, self._threshold * self._threshold_ratio)
+        return self._threshold

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/terminator/terminator.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import abc
+
+from optuna._experimental import experimental_class
+from optuna.study.study import Study
+from optuna.terminator.erroreval import BaseErrorEvaluator
+from optuna.terminator.erroreval import CrossValidationErrorEvaluator
+from optuna.terminator.erroreval import StaticErrorEvaluator
+from optuna.terminator.improvement.evaluator import BaseImprovementEvaluator
+from optuna.terminator.improvement.evaluator import BestValueStagnationEvaluator
+from optuna.terminator.improvement.evaluator import DEFAULT_MIN_N_TRIALS
+from optuna.terminator.improvement.evaluator import RegretBoundEvaluator
+from optuna.trial import TrialState
+
+
+class BaseTerminator(metaclass=abc.ABCMeta):
+    """Base class for terminators."""
+
+    @abc.abstractmethod
+    def should_terminate(self, study: Study) -> bool:
+        pass
+
+
+@experimental_class("3.2.0")
+class Terminator(BaseTerminator):
+    """Automatic stopping mechanism for Optuna studies.
+
+    This class implements an automatic stopping mechanism for Optuna studies, aiming to prevent
+    unnecessary computation. The study is terminated when the statistical error, e.g.
+    cross-validation error, exceeds the room left for optimization.
+
+    For further information about the algorithm, please refer to the following paper:
+
+    - `A. Makarova et al. Automatic termination for hyperparameter optimization.
+      <https://proceedings.mlr.press/v188/makarova22a.html>`__
+
+    Args:
+        improvement_evaluator:
+            An evaluator object for assessing the room left for optimization. Defaults to a
+            :class:`~optuna.terminator.improvement.evaluator.RegretBoundEvaluator` object.
+        error_evaluator:
+            An evaluator for calculating the statistical error, e.g. cross-validation error.
+            Defaults to a :class:`~optuna.terminator.CrossValidationErrorEvaluator`
+            object.
+        min_n_trials:
+            The minimum number of trials before termination is considered. Defaults to ``20``.
+
+    Raises:
+        ValueError: If ``min_n_trials`` is not a positive integer.
+
+    Example:
+
+        .. testcode::
+
+            import logging
+            import sys
+
+            from sklearn.datasets import load_wine
+            from sklearn.ensemble import RandomForestClassifier
+            from sklearn.model_selection import cross_val_score
+            from sklearn.model_selection import KFold
+
+            import optuna
+            from optuna.terminator import Terminator
+            from optuna.terminator import report_cross_validation_scores
+
+
+            study = optuna.create_study(direction="maximize")
+            terminator = Terminator()
+            min_n_trials = 20
+
+            while True:
+                trial = study.ask()
+
+                X, y = load_wine(return_X_y=True)
+
+                clf = RandomForestClassifier(
+                    max_depth=trial.suggest_int("max_depth", 2, 32),
+                    min_samples_split=trial.suggest_float("min_samples_split", 0, 1),
+                    criterion=trial.suggest_categorical("criterion", ("gini", "entropy")),
+                )
+
+                scores = cross_val_score(clf, X, y, cv=KFold(n_splits=5, shuffle=True))
+                report_cross_validation_scores(trial, scores)
+
+                value = scores.mean()
+                logging.info(f"Trial #{trial.number} finished with value {value}.")
+                study.tell(trial, value)
+
+                if trial.number > min_n_trials and terminator.should_terminate(study):
+                    logging.info("Terminated by Optuna Terminator!")
+                    break
+
+    .. seealso::
+        Please refer to :class:`~optuna.terminator.TerminatorCallback` for how to use
+        the terminator mechanism with the :func:`~optuna.study.Study.optimize` method.
+
+    """
+
+    def __init__(
+        self,
+        improvement_evaluator: BaseImprovementEvaluator | None = None,
+        error_evaluator: BaseErrorEvaluator | None = None,
+        min_n_trials: int = DEFAULT_MIN_N_TRIALS,
+    ) -> None:
+        if min_n_trials <= 0:
+            raise ValueError("`min_n_trials` is expected to be a positive integer.")
+
+        self._improvement_evaluator = improvement_evaluator or RegretBoundEvaluator()
+        self._error_evaluator = error_evaluator or self._initialize_error_evaluator()
+        self._min_n_trials = min_n_trials
+
+    def _initialize_error_evaluator(self) -> BaseErrorEvaluator:
+        if isinstance(self._improvement_evaluator, BestValueStagnationEvaluator):
+            return StaticErrorEvaluator(constant=0)
+        return CrossValidationErrorEvaluator()
+
+    def should_terminate(self, study: Study) -> bool:
+        """Judge whether the study should be terminated based on the reported values."""
+        trials = study.get_trials(states=[TrialState.COMPLETE])
+
+        if len(trials) < self._min_n_trials:
+            return False
+
+        improvement = self._improvement_evaluator.evaluate(
+            trials=study.trials,
+            study_direction=study.direction,
+        )
+
+        error = self._error_evaluator.evaluate(
+            trials=study.trials, study_direction=study.direction
+        )
+
+        should_terminate = improvement < error
+        return should_terminate

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/objectives.py

@@ -0,0 +1,10 @@
+from optuna import TrialPruned
+from optuna.trial import Trial
+
+
+def fail_objective(_: Trial) -> float:
+    raise ValueError()
+
+
+def pruned_objective(trial: Trial) -> float:
+    raise TrialPruned()

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/pruners.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import optuna
+
+
+class DeterministicPruner(optuna.pruners.BasePruner):
+    def __init__(self, is_pruning: bool) -> None:
+        self.is_pruning = is_pruning
+
+    def prune(self, study: "optuna.study.Study", trial: "optuna.trial.FrozenTrial") -> bool:
+        return self.is_pruning

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/samplers.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Any
+
+import optuna
+from optuna.distributions import BaseDistribution
+
+
+class DeterministicSampler(optuna.samplers.BaseSampler):
+    def __init__(self, params: dict[str, Any]) -> None:
+        self.params = params
+
+    def infer_relative_search_space(
+        self, study: "optuna.study.Study", trial: "optuna.trial.FrozenTrial"
+    ) -> dict[str, BaseDistribution]:
+        return {}
+
+    def sample_relative(
+        self,
+        study: "optuna.study.Study",
+        trial: "optuna.trial.FrozenTrial",
+        search_space: dict[str, BaseDistribution],
+    ) -> dict[str, Any]:
+        return {}
+
+    def sample_independent(
+        self,
+        study: "optuna.study.Study",
+        trial: "optuna.trial.FrozenTrial",
+        param_name: str,
+        param_distribution: BaseDistribution,
+    ) -> Any:
+        param_value = self.params[param_name]
+        assert param_distribution._contains(param_distribution.to_internal_repr(param_value))
+        return param_value

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/storages.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import AbstractContextManager
+from contextlib import contextmanager
+import os
+import socket
+import sys
+import threading
+from types import TracebackType
+from typing import Any
+from typing import Generator
+from typing import IO
+from typing import TYPE_CHECKING
+
+import fakeredis
+
+import optuna
+from optuna.storages import BaseStorage
+from optuna.storages import GrpcStorageProxy
+from optuna.storages.journal import JournalFileBackend
+from optuna.testing.tempfile_pool import NamedTemporaryFilePool
+
+
+if TYPE_CHECKING:
+    import grpc
+else:
+    from optuna._imports import _LazyImport
+
+    grpc = _LazyImport("grpc")
+
+
+STORAGE_MODES: list[Any] = [
+    "inmemory",
+    "sqlite",
+    "cached_sqlite",
+    "journal",
+    "journal_redis",
+    "grpc_rdb",
+    "grpc_journal_file",
+]
+
+
+STORAGE_MODES_HEARTBEAT = [
+    "sqlite",
+    "cached_sqlite",
+]
+
+SQLITE3_TIMEOUT = 300
+
+
+@contextmanager
+def _lock_to_search_for_free_port() -> Generator[None, None, None]:
+    if sys.platform == "win32":
+        lock_path = os.path.join(
+            os.environ.get("PROGRAMDATA", "C:\\ProgramData"),
+            "optuna",
+            "optuna_find_free_port.lock",
+        )
+    else:
+        lock_path = "/tmp/optuna_find_free_port.lock"
+
+    os.makedirs(os.path.dirname(lock_path), exist_ok=True)
+    lockfile = open(lock_path, "w")
+    if sys.platform == "win32":
+        import msvcrt
+
+        msvcrt.locking(lockfile.fileno(), msvcrt.LK_LOCK, 1)
+        yield
+        msvcrt.locking(lockfile.fileno(), msvcrt.LK_UNLCK, 1)
+    else:
+        import fcntl
+
+        fcntl.flock(lockfile, fcntl.LOCK_EX)
+        yield
+        fcntl.flock(lockfile, fcntl.LOCK_UN)
+
+    lockfile.close()
+
+
+class StorageSupplier(AbstractContextManager):
+    def __init__(self, storage_specifier: str, **kwargs: Any) -> None:
+        self.storage_specifier = storage_specifier
+        self.extra_args = kwargs
+        self.tempfile: IO[Any] | None = None
+        self.server: grpc.Server | None = None
+        self.thread: threading.Thread | None = None
+        self.proxy: GrpcStorageProxy | None = None
+
+    def __enter__(
+        self,
+    ) -> (
+        optuna.storages.InMemoryStorage
+        | optuna.storages._CachedStorage
+        | optuna.storages.RDBStorage
+        | optuna.storages.JournalStorage
+        | optuna.storages.GrpcStorageProxy
+    ):
+        if self.storage_specifier == "inmemory":
+            if len(self.extra_args) > 0:
+                raise ValueError("InMemoryStorage does not accept any arguments!")
+            return optuna.storages.InMemoryStorage()
+        elif "sqlite" in self.storage_specifier:
+            self.tempfile = NamedTemporaryFilePool().tempfile()
+            url = "sqlite:///{}".format(self.tempfile.name)
+            rdb_storage = optuna.storages.RDBStorage(
+                url,
+                engine_kwargs={"connect_args": {"timeout": SQLITE3_TIMEOUT}},
+                **self.extra_args,
+            )
+            return (
+                optuna.storages._CachedStorage(rdb_storage)
+                if "cached" in self.storage_specifier
+                else rdb_storage
+            )
+        elif self.storage_specifier == "journal_redis":
+            journal_redis_storage = optuna.storages.journal.JournalRedisBackend(
+                "redis://localhost"
+            )
+            journal_redis_storage._redis = self.extra_args.get(
+                "redis", fakeredis.FakeStrictRedis()
+            )
+            return optuna.storages.JournalStorage(journal_redis_storage)
+        elif self.storage_specifier == "grpc_journal_file":
+            self.tempfile = self.extra_args.get("file", NamedTemporaryFilePool().tempfile())
+            assert self.tempfile is not None
+            storage = optuna.storages.JournalStorage(
+                optuna.storages.journal.JournalFileBackend(self.tempfile.name)
+            )
+            return self._create_proxy(storage, thread_pool=self.extra_args.get("thread_pool"))
+        elif "journal" in self.storage_specifier:
+            self.tempfile = self.extra_args.get("file", NamedTemporaryFilePool().tempfile())
+            assert self.tempfile is not None
+            file_storage = JournalFileBackend(self.tempfile.name)
+            return optuna.storages.JournalStorage(file_storage)
+        elif self.storage_specifier == "grpc_rdb":
+            self.tempfile = NamedTemporaryFilePool().tempfile()
+            url = "sqlite:///{}".format(self.tempfile.name)
+            return self._create_proxy(optuna.storages.RDBStorage(url))
+        elif self.storage_specifier == "grpc_proxy":
+            assert "base_storage" in self.extra_args
+            return self._create_proxy(self.extra_args["base_storage"])
+        else:
+            assert False
+
+    def _create_proxy(
+        self, storage: BaseStorage, thread_pool: ThreadPoolExecutor | None = None
+    ) -> GrpcStorageProxy:
+        with _lock_to_search_for_free_port():
+            port = _find_free_port()
+            self.server = optuna.storages._grpc.server.make_server(
+                storage, "localhost", port, thread_pool=thread_pool
+            )
+            self.thread = threading.Thread(target=self.server.start)
+            self.thread.start()
+            self.proxy = GrpcStorageProxy(host="localhost", port=port)
+            self.proxy.wait_server_ready(timeout=60)
+            return self.proxy
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        if self.tempfile:
+            self.tempfile.close()
+
+        if self.proxy:
+            self.proxy.close()
+            self.proxy = None
+
+        if self.server:
+            assert self.thread is not None
+            self.server.stop(5).wait()
+            self.thread.join()
+            self.server = None
+            self.thread = None
+
+
+def _find_free_port() -> int:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    for port in range(13000, 13100):
+        try:
+            sock.bind(("localhost", port))
+            return port
+        except OSError:
+            continue
+    assert False, "must not reach here"

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/tempfile_pool.py

@@ -0,0 +1,46 @@
+# On Windows, temporary file shold delete "after" storage was deleted
+# NamedTemporaryFilePool ensures tempfile delete after tests.
+
+from __future__ import annotations
+
+import atexit
+import gc
+import os
+import tempfile
+from types import TracebackType
+from typing import Any
+from typing import IO
+
+
+class NamedTemporaryFilePool:
+    tempfile_pool: list[IO[Any]] = []
+
+    def __new__(cls, **kwargs: Any) -> "NamedTemporaryFilePool":
+        if not hasattr(cls, "_instance"):
+            cls._instance = super(NamedTemporaryFilePool, cls).__new__(cls)
+            atexit.register(cls._instance.cleanup)
+        return cls._instance
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.kwargs = kwargs
+
+    def tempfile(self) -> IO[Any]:
+        self._tempfile = tempfile.NamedTemporaryFile(delete=False, **self.kwargs)
+        self.tempfile_pool.append(self._tempfile)
+        return self._tempfile
+
+    def cleanup(self) -> None:
+        gc.collect()
+        for i in self.tempfile_pool:
+            os.unlink(i.name)
+
+    def __enter__(self) -> IO[Any]:
+        return self.tempfile()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._tempfile.close()

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/threading.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+import threading
+from typing import Any
+
+
+class _TestableThread(threading.Thread):
+    def __init__(self, target: Callable[..., Any], args: tuple):
+        threading.Thread.__init__(self, target=target, args=args)
+        self.exc: BaseException | None = None
+
+    def run(self) -> None:
+        try:
+            threading.Thread.run(self)
+        except BaseException as e:
+            self.exc = e
+
+    def join(self, timeout: float | None = None) -> None:
+        super(_TestableThread, self).join(timeout)
+        if self.exc:
+            raise self.exc

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/trials.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import optuna
+from optuna.distributions import BaseDistribution
+from optuna.samplers._base import _CONSTRAINTS_KEY
+from optuna.trial import FrozenTrial
+from optuna.trial import TrialState
+
+
+def _create_frozen_trial(
+    number: int = 0,
+    values: Sequence[float] | None = None,
+    constraints: Sequence[float] | None = None,
+    params: dict[str, Any] | None = None,
+    param_distributions: dict[str, BaseDistribution] | None = None,
+    state: TrialState = TrialState.COMPLETE,
+) -> optuna.trial.FrozenTrial:
+    return FrozenTrial(
+        number=number,
+        value=1.0 if values is None else None,
+        values=values,
+        state=state,
+        user_attrs={},
+        system_attrs={} if constraints is None else {_CONSTRAINTS_KEY: list(constraints)},
+        params=params or {},
+        distributions=param_distributions or {},
+        intermediate_values={},
+        datetime_start=None,
+        datetime_complete=None,
+        trial_id=number,
+    )

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/testing/visualization.py

@@ -0,0 +1,67 @@
+from optuna import Study
+from optuna.distributions import FloatDistribution
+from optuna.study import create_study
+from optuna.trial import create_trial
+
+
+def prepare_study_with_trials(
+    n_objectives: int = 1,
+    direction: str = "minimize",
+    value_for_first_trial: float = 0.0,
+) -> Study:
+    """Return a dummy study object for tests.
+
+    This function is added to reduce the code to set up dummy study object in each test case.
+    However, you can only use this function for unit tests that are loosely coupled with the
+    dummy study object. Unit tests that are tightly coupled with the study become difficult to
+    read because of
+    `Mystery Guest <http://xunitpatterns.com/Obscure%20Test.html#Mystery%20Guest>`__ and/or
+    `Eager Test <http://xunitpatterns.com/Obscure%20Test.html#Eager%20Test>`__ anti-patterns.
+
+    Args:
+        n_objectives: Number of objective values.
+        direction: Study's optimization direction.
+        value_for_first_trial: Objective value in first trial. This value will be broadcasted
+            to all objectives in multi-objective optimization.
+
+    Returns:
+        :class:`~optuna.study.Study`
+
+    """
+
+    study = create_study(directions=[direction] * n_objectives)
+    study.add_trial(
+        create_trial(
+            values=[value_for_first_trial] * n_objectives,
+            params={"param_a": 1.0, "param_b": 2.0, "param_c": 3.0, "param_d": 4.0},
+            distributions={
+                "param_a": FloatDistribution(0.0, 3.0),
+                "param_b": FloatDistribution(0.0, 3.0),
+                "param_c": FloatDistribution(2.0, 5.0),
+                "param_d": FloatDistribution(2.0, 5.0),
+            },
+        )
+    )
+    study.add_trial(
+        create_trial(
+            values=[2.0] * n_objectives,
+            params={"param_b": 0.0, "param_d": 4.0},
+            distributions={
+                "param_b": FloatDistribution(0.0, 3.0),
+                "param_d": FloatDistribution(2.0, 5.0),
+            },
+        )
+    )
+    study.add_trial(
+        create_trial(
+            values=[1.0] * n_objectives,
+            params={"param_a": 2.5, "param_b": 1.0, "param_c": 4.5, "param_d": 2.0},
+            distributions={
+                "param_a": FloatDistribution(0.0, 3.0),
+                "param_b": FloatDistribution(0.0, 3.0),
+                "param_c": FloatDistribution(2.0, 5.0),
+                "param_d": FloatDistribution(2.0, 5.0),
+            },
+        )
+    )
+    return study

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/trial/__init__.py

@@ -0,0 +1,16 @@
+from optuna.trial._base import BaseTrial
+from optuna.trial._fixed import FixedTrial
+from optuna.trial._frozen import create_trial
+from optuna.trial._frozen import FrozenTrial
+from optuna.trial._state import TrialState
+from optuna.trial._trial import Trial
+
+
+__all__ = [
+    "BaseTrial",
+    "FixedTrial",
+    "FrozenTrial",
+    "Trial",
+    "TrialState",
+    "create_trial",
+]

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/trial/_base.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import abc
+from collections.abc import Sequence
+import datetime
+from typing import Any
+from typing import overload
+
+from optuna._deprecated import deprecated_func
+from optuna.distributions import BaseDistribution
+from optuna.distributions import CategoricalChoiceType
+
+
+_SUGGEST_INT_POSITIONAL_ARGS = ["self", "name", "low", "high", "step", "log"]
+
+
+class BaseTrial(abc.ABC):
+    """Base class for trials.
+
+    Note that this class is not supposed to be directly accessed by library users.
+    """
+
+    @abc.abstractmethod
+    def suggest_float(
+        self,
+        name: str,
+        low: float,
+        high: float,
+        *,
+        step: float | None = None,
+        log: bool = False,
+    ) -> float:
+        raise NotImplementedError
+
+    @deprecated_func("3.0.0", "6.0.0")
+    @abc.abstractmethod
+    def suggest_uniform(self, name: str, low: float, high: float) -> float:
+        raise NotImplementedError
+
+    @deprecated_func("3.0.0", "6.0.0")
+    @abc.abstractmethod
+    def suggest_loguniform(self, name: str, low: float, high: float) -> float:
+        raise NotImplementedError
+
+    @deprecated_func("3.0.0", "6.0.0")
+    @abc.abstractmethod
+    def suggest_discrete_uniform(self, name: str, low: float, high: float, q: float) -> float:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def suggest_int(
+        self, name: str, low: int, high: int, *, step: int = 1, log: bool = False
+    ) -> int:
+        raise NotImplementedError
+
+    @overload
+    @abc.abstractmethod
+    def suggest_categorical(self, name: str, choices: Sequence[None]) -> None: ...
+
+    @overload
+    @abc.abstractmethod
+    def suggest_categorical(self, name: str, choices: Sequence[bool]) -> bool: ...
+
+    @overload
+    @abc.abstractmethod
+    def suggest_categorical(self, name: str, choices: Sequence[int]) -> int: ...
+
+    @overload
+    @abc.abstractmethod
+    def suggest_categorical(self, name: str, choices: Sequence[float]) -> float: ...
+
+    @overload
+    @abc.abstractmethod
+    def suggest_categorical(self, name: str, choices: Sequence[str]) -> str: ...
+
+    @overload
+    @abc.abstractmethod
+    def suggest_categorical(
+        self, name: str, choices: Sequence[CategoricalChoiceType]
+    ) -> CategoricalChoiceType: ...
+
+    @abc.abstractmethod
+    def suggest_categorical(
+        self, name: str, choices: Sequence[CategoricalChoiceType]
+    ) -> CategoricalChoiceType:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def report(self, value: float, step: int) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def should_prune(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def set_user_attr(self, key: str, value: Any) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    @deprecated_func("3.1.0", "5.0.0")
+    def set_system_attr(self, key: str, value: Any) -> None:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def params(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def distributions(self) -> dict[str, BaseDistribution]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def user_attrs(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def system_attrs(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def datetime_start(self) -> datetime.datetime | None:
+        raise NotImplementedError
+
+    @property
+    def number(self) -> int:
+        raise NotImplementedError

Scripts_Climate_to_LAI/.venv/lib/python3.10/site-packages/optuna/trial/_fixed.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+import datetime
+from typing import Any
+from typing import overload
+import warnings
+
+from optuna import distributions
+from optuna._convert_positional_args import convert_positional_args
+from optuna._deprecated import deprecated_func
+from optuna.distributions import BaseDistribution
+from optuna.distributions import CategoricalChoiceType
+from optuna.distributions import CategoricalDistribution
+from optuna.distributions import FloatDistribution
+from optuna.distributions import IntDistribution
+from optuna.trial._base import _SUGGEST_INT_POSITIONAL_ARGS
+from optuna.trial._base import BaseTrial
+
+
+_suggest_deprecated_msg = "Use suggest_float{args} instead."
+
+
+class FixedTrial(BaseTrial):
+    """A trial class which suggests a fixed value for each parameter.
+
+    This object has the same methods as :class:`~optuna.trial.Trial`, and it suggests pre-defined
+    parameter values. The parameter values can be determined at the construction of the
+    :class:`~optuna.trial.FixedTrial` object. In contrast to :class:`~optuna.trial.Trial`,
+    :class:`~optuna.trial.FixedTrial` does not depend on :class:`~optuna.study.Study`, and it is
+    useful for deploying optimization results.
+
+    Example:
+
+        Evaluate an objective function with parameter values given by a user.
+
+        .. testcode::
+
+            import optuna
+
+
+            def objective(trial):
+                x = trial.suggest_float("x", -100, 100)
+                y = trial.suggest_categorical("y", [-1, 0, 1])
+                return x**2 + y
+
+
+            assert objective(optuna.trial.FixedTrial({"x": 1, "y": 0})) == 1
+
+
+    .. note::
+        Please refer to :class:`~optuna.trial.Trial` for details of methods and properties.
+
+    Args:
+        params:
+            A dictionary containing all parameters.
+        number:
+            A trial number. Defaults to ``0``.
+
+    """
+
+    def __init__(self, params: dict[str, Any], number: int = 0) -> None:
+        self._params = params
+        self._suggested_params: dict[str, Any] = {}
+        self._distributions: dict[str, BaseDistribution] = {}
+        self._user_attrs: dict[str, Any] = {}
+        self._system_attrs: dict[str, Any] = {}
+        self._datetime_start = datetime.datetime.now()
+        self._number = number
+
+    def suggest_float(
+        self,
+        name: str,
+        low: float,
+        high: float,
+        *,
+        step: float | None = None,
+        log: bool = False,
+    ) -> float:
+        return self._suggest(name, FloatDistribution(low, high, log=log, step=step))
+
+    @deprecated_func("3.0.0", "6.0.0", text=_suggest_deprecated_msg.format(args=""))
+    def suggest_uniform(self, name: str, low: float, high: float) -> float:
+        return self.suggest_float(name, low, high)
+
+    @deprecated_func("3.0.0", "6.0.0", text=_suggest_deprecated_msg.format(args="(..., log=True)"))
+    def suggest_loguniform(self, name: str, low: float, high: float) -> float:
+        return self.suggest_float(name, low, high, log=True)
+
+    @deprecated_func("3.0.0", "6.0.0", text=_suggest_deprecated_msg.format(args="(..., step=...)"))
+    def suggest_discrete_uniform(self, name: str, low: float, high: float, q: float) -> float:
+        return self.suggest_float(name, low, high, step=q)
+
+    @convert_positional_args(
+        previous_positional_arg_names=_SUGGEST_INT_POSITIONAL_ARGS,
+        deprecated_version="3.5.0",
+        removed_version="5.0.0",
+    )
+    def suggest_int(
+        self, name: str, low: int, high: int, *, step: int = 1, log: bool = False
+    ) -> int:
+        return int(self._suggest(name, IntDistribution(low, high, log=log, step=step)))
+
+    @overload
+    def suggest_categorical(self, name: str, choices: Sequence[None]) -> None: ...
+
+    @overload
+    def suggest_categorical(self, name: str, choices: Sequence[bool]) -> bool: ...
+
+    @overload
+    def suggest_categorical(self, name: str, choices: Sequence[int]) -> int: ...
+
+    @overload
+    def suggest_categorical(self, name: str, choices: Sequence[float]) -> float: ...
+
+    @overload
+    def suggest_categorical(self, name: str, choices: Sequence[str]) -> str: ...
+
+    @overload
+    def suggest_categorical(
+        self, name: str, choices: Sequence[CategoricalChoiceType]
+    ) -> CategoricalChoiceType: ...
+
+    def suggest_categorical(
+        self, name: str, choices: Sequence[CategoricalChoiceType]
+    ) -> CategoricalChoiceType:
+        return self._suggest(name, CategoricalDistribution(choices=choices))
+
+    def report(self, value: float, step: int) -> None:
+        pass
+
+    def should_prune(self) -> bool:
+        return False
+
+    def set_user_attr(self, key: str, value: Any) -> None:
+        self._user_attrs[key] = value
+
+    @deprecated_func("3.1.0", "5.0.0")
+    def set_system_attr(self, key: str, value: Any) -> None:
+        self._system_attrs[key] = value
+
+    def _suggest(self, name: str, distribution: BaseDistribution) -> Any:
+        if name not in self._params:
+            raise ValueError(
+                "The value of the parameter '{}' is not found. Please set it at "
+                "the construction of the FixedTrial object.".format(name)
+            )
+
+        value = self._params[name]
+        param_value_in_internal_repr = distribution.to_internal_repr(value)
+        if not distribution._contains(param_value_in_internal_repr):
+            warnings.warn(
+                "The value {} of the parameter '{}' is out of "
+                "the range of the distribution {}.".format(value, name, distribution)
+            )
+
+        if name in self._distributions:
+            distributions.check_distribution_compatibility(self._distributions[name], distribution)
+
+        self._suggested_params[name] = value
+        self._distributions[name] = distribution
+
+        return value
+
+    @property
+    def params(self) -> dict[str, Any]:
+        return self._suggested_params
+
+    @property
+    def distributions(self) -> dict[str, BaseDistribution]:
+        return self._distributions
+
+    @property
+    def user_attrs(self) -> dict[str, Any]:
+        return self._user_attrs
+
+    @property
+    def system_attrs(self) -> dict[str, Any]:
+        return self._system_attrs
+
+    @property
+    def datetime_start(self) -> datetime.datetime | None:
+        return self._datetime_start
+
+    @property
+    def number(self) -> int:
+        return self._number