hydra-optuna-sweeper 1.4.0.dev4__tar.gz → 1.4.0.dev6__tar.gz

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydra-optuna-sweeper
-Version: 1.4.0.dev4
+Version: 1.4.0.dev6
 Summary: Hydra Optuna Sweeper plugin
 Home-page: https://github.com/facebookresearch/hydra/
 Author: Toshihiko Yanase, Hiroyuki Vincent Yamazaki
@@ -17,8 +17,7 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: hydra-core>=1.1.0.dev7
-Requires-Dist: optuna<3.0.0,>=2.10.0
-Requires-Dist: sqlalchemy~=1.3.0
+Requires-Dist: optuna<5.0.0,>=4.9.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/hydra_optuna_sweeper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydra-optuna-sweeper
-Version: 1.4.0.dev4
+Version: 1.4.0.dev6
 Summary: Hydra Optuna Sweeper plugin
 Home-page: https://github.com/facebookresearch/hydra/
 Author: Toshihiko Yanase, Hiroyuki Vincent Yamazaki
@@ -17,8 +17,7 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: hydra-core>=1.1.0.dev7
-Requires-Dist: optuna<3.0.0,>=2.10.0
-Requires-Dist: sqlalchemy~=1.3.0
+Requires-Dist: optuna<5.0.0,>=4.9.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

hydra_optuna_sweeper-1.4.0.dev6/hydra_optuna_sweeper.egg-info/requires.txt

@@ -0,0 +1,2 @@
+hydra-core>=1.1.0.dev7
+optuna<5.0.0,>=4.9.0

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/hydra_plugins/hydra_optuna_sweeper/__init__.py

@@ -1,3 +1,3 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
 
-__version__ = "1.4.0.dev4"
+__version__ = "1.4.0.dev6"

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/hydra_plugins/hydra_optuna_sweeper/_impl.py

@@ -35,11 +35,8 @@ from optuna.distributions import (
     BaseDistribution,
     CategoricalChoiceType,
     CategoricalDistribution,
-    DiscreteUniformDistribution,
-    IntLogUniformDistribution,
-    IntUniformDistribution,
-    LogUniformDistribution,
-    UniformDistribution,
+    FloatDistribution,
+    IntDistribution,
 )
 from optuna.trial import Trial
 
@@ -62,17 +59,17 @@ def create_optuna_distribution_from_config(
         assert param.low is not None
         assert param.high is not None
         if param.log:
-            return IntLogUniformDistribution(int(param.low), int(param.high))
+            return IntDistribution(int(param.low), int(param.high), log=True)
         step = int(param.step) if param.step is not None else 1
-        return IntUniformDistribution(int(param.low), int(param.high), step=step)
+        return IntDistribution(int(param.low), int(param.high), step=step)
     if param.type == DistributionType.float:
         assert param.low is not None
         assert param.high is not None
         if param.log:
-            return LogUniformDistribution(param.low, param.high)
+            return FloatDistribution(param.low, param.high, log=True)
         if param.step is not None:
-            return DiscreteUniformDistribution(param.low, param.high, param.step)
-        return UniformDistribution(param.low, param.high)
+            return FloatDistribution(param.low, param.high, step=param.step)
+        return FloatDistribution(param.low, param.high)
     raise NotImplementedError(f"{param.type} is not supported by Optuna sweeper.")
 
 
@@ -107,10 +104,12 @@ def create_optuna_distribution_from_override(override: Override) -> Any:
             or isinstance(value.stop, float)
             or isinstance(value.step, float)
         ):
-            return DiscreteUniformDistribution(value.start, value.stop, value.step)
-        return IntUniformDistribution(
-            int(value.start), int(value.stop), step=int(value.step)
-        )
+            return FloatDistribution(
+                float(value.start),
+                float(value.stop),
+                step=float(value.step) if value.step else None,
+            )
+        return IntDistribution(int(value.start), int(value.stop), step=int(value.step))
 
     if override.is_interval_sweep():
         assert isinstance(value, IntervalSweep)
@@ -118,32 +117,37 @@ def create_optuna_distribution_from_override(override: Override) -> Any:
         assert value.end is not None
         if "log" in value.tags:
             if isinstance(value.start, int) and isinstance(value.end, int):
-                return IntLogUniformDistribution(int(value.start), int(value.end))
-            return LogUniformDistribution(value.start, value.end)
+                return IntDistribution(int(value.start), int(value.end), log=True)
+            return FloatDistribution(value.start, value.end, log=True)
         else:
             if isinstance(value.start, int) and isinstance(value.end, int):
-                return IntUniformDistribution(value.start, value.end)
-            return UniformDistribution(value.start, value.end)
+                return IntDistribution(value.start, value.end)
+            return FloatDistribution(value.start, value.end)
 
     raise NotImplementedError(f"{override} is not supported by Optuna sweeper.")
 
 
 def create_params_from_overrides(
     arguments: List[str],
-) -> Tuple[Dict[str, BaseDistribution], Dict[str, Any]]:
+) -> Tuple[Dict[str, BaseDistribution], Dict[str, Any], List[str]]:
     parser = OverridesParser.create()
     parsed = parser.parse_overrides(arguments)
     search_space_distributions = dict()
     fixed_params = dict()
+    fixed_overrides = []
 
     for override in parsed:
+        if override.is_delete():
+            assert override.input_line is not None
+            fixed_overrides.append(override.input_line)
+            continue
         param_name = override.get_key_element()
         value = create_optuna_distribution_from_override(override)
         if isinstance(value, BaseDistribution):
             search_space_distributions[param_name] = value
         else:
             fixed_params[param_name] = value
-    return search_space_distributions, fixed_params
+    return search_space_distributions, fixed_params, fixed_overrides
 
 
 class OptunaSweeperImpl(Sweeper):
@@ -230,6 +234,7 @@ class OptunaSweeperImpl(Sweeper):
         trials: List[Trial],
         search_space_distributions: Dict[str, BaseDistribution],
         fixed_params: Dict[str, Any],
+        fixed_overrides: List[str],
     ) -> Sequence[Sequence[str]]:
         overrides = []
         for trial in trials:
@@ -252,7 +257,10 @@ class OptunaSweeperImpl(Sweeper):
             params = dict(trial.params)
             params.update(fixed_params)
 
-            overrides.append(tuple(f"{name}={val}" for name, val in params.items()))
+            overrides.append(
+                tuple(f"{name}={val}" for name, val in params.items())
+                + tuple(fixed_overrides)
+            )
         return overrides
 
     def _parse_sweeper_params_config(self) -> List[str]:
@@ -264,15 +272,18 @@ class OptunaSweeperImpl(Sweeper):
     def _to_grid_sampler_choices(self, distribution: BaseDistribution) -> Any:
         if isinstance(distribution, CategoricalDistribution):
             return distribution.choices
-        elif isinstance(distribution, IntUniformDistribution):
+        elif isinstance(distribution, IntDistribution):
             assert (
                 distribution.step is not None
-            ), "`step` of IntUniformDistribution must be a positive integer."
+            ), "`step` of IntDistribution must be a positive integer."
             n_items = (distribution.high - distribution.low) // distribution.step
             return [distribution.low + i * distribution.step for i in range(n_items)]
-        elif isinstance(distribution, DiscreteUniformDistribution):
-            n_items = int((distribution.high - distribution.low) // distribution.q)
-            return [distribution.low + i * distribution.q for i in range(n_items)]
+        elif (
+            isinstance(distribution, FloatDistribution)
+            and distribution.step is not None
+        ):
+            n_items = int((distribution.high - distribution.low) // distribution.step)
+            return [distribution.low + i * distribution.step for i in range(n_items)]
         else:
             raise ValueError("GridSampler only supports discrete distributions.")
 
@@ -294,6 +305,7 @@ class OptunaSweeperImpl(Sweeper):
         (
             override_search_space_distributions,
             fixed_params,
+            fixed_overrides,
         ) = create_params_from_overrides(params_conf)
 
         search_space_distributions = dict()
@@ -343,7 +355,7 @@ class OptunaSweeperImpl(Sweeper):
 
             trials = [study.ask() for _ in range(batch_size)]
             overrides = self._configure_trials(
-                trials, search_space_distributions, fixed_params
+                trials, search_space_distributions, fixed_params, fixed_overrides
             )
 
             returns = self.launcher.launch(overrides, initial_job_idx=self.job_idx)

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/hydra_plugins/hydra_optuna_sweeper/config.py

@@ -1,12 +1,20 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, NoReturn, Optional
 
 from hydra.core.config_store import ConfigStore
 from omegaconf import MISSING
 
 
+def raise_motpe_removed(*args: Any, **kwargs: Any) -> NoReturn:
+    raise ValueError(
+        "The 'motpe' sampler was removed in Optuna 4.0. "
+        "Use 'hydra/sweeper/sampler=tpe' instead. "
+        "TPESampler now handles multi-objective optimization."
+    )
+
+
 class DistributionType(Enum):
     int = 1
     float = 2
@@ -43,14 +51,14 @@ class TPESamplerConfig(SamplerConfig):
     _target_: str = "optuna.samplers.TPESampler"
     seed: Optional[int] = None
 
-    consider_prior: bool = True
-    prior_weight: float = 1.0
-    consider_magic_clip: bool = True
-    consider_endpoints: bool = False
+    consider_prior: Optional[bool] = None
+    prior_weight: Optional[float] = None
+    consider_magic_clip: Optional[bool] = None
+    consider_endpoints: Optional[bool] = None
     n_startup_trials: int = 10
     n_ei_candidates: int = 24
     multivariate: bool = False
-    warn_independent_sampling: bool = True
+    warn_independent_sampling: Optional[bool] = None
 
 
 @dataclass
@@ -101,19 +109,39 @@ class NSGAIISamplerConfig(SamplerConfig):
 
 @dataclass
 class MOTPESamplerConfig(SamplerConfig):
+    _target_: str = "hydra_plugins.hydra_optuna_sweeper.config.raise_motpe_removed"
+
+
+@dataclass
+class GPSamplerConfig(SamplerConfig):
     """
-    https://optuna.readthedocs.io/en/stable/reference/generated/optuna.samplers.MOTPESampler.html
+    https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.GPSampler.html
     """
 
-    _target_: str = "optuna.samplers.MOTPESampler"
+    _target_: str = "optuna.samplers.GPSampler"
     seed: Optional[int] = None
 
-    consider_prior: bool = True
-    prior_weight: float = 1.0
-    consider_magic_clip: bool = True
-    consider_endpoints: bool = False
+    independent_sampler: Optional[Any] = None
     n_startup_trials: int = 10
-    n_ehvi_candidates: int = 24
+    deterministic_objective: bool = False
+    constraints_func: Optional[Any] = None
+    warn_independent_sampling: bool = True
+
+
+@dataclass
+class QMCSamplerConfig(SamplerConfig):
+    """
+    https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.QMCSampler.html
+    """
+
+    _target_: str = "optuna.samplers.QMCSampler"
+    seed: Optional[int] = None
+
+    qmc_type: str = "sobol"
+    scramble: bool = False
+    independent_sampler: Optional[Any] = None
+    warn_asynchronous_seeding: bool = True
+    warn_independent_sampling: bool = True
 
 
 @dataclass
@@ -234,3 +262,17 @@ ConfigStore.instance().store(
     node=GridSamplerConfig,
     provider="optuna_sweeper",
 )
+
+ConfigStore.instance().store(
+    group="hydra/sweeper/sampler",
+    name="gp",
+    node=GPSamplerConfig,
+    provider="optuna_sweeper",
+)
+
+ConfigStore.instance().store(
+    group="hydra/sweeper/sampler",
+    name="qmc",
+    node=QMCSamplerConfig,
+    provider="optuna_sweeper",
+)

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/setup.py

@@ -29,8 +29,7 @@ setup(
     python_requires=">=3.10",
     install_requires=[
         "hydra-core>=1.1.0.dev7",
-        "optuna>=2.10.0,<3.0.0",
-        "sqlalchemy~=1.3.0",  # TODO: Unpin when upgrading to optuna v3.0
+        "optuna>=4.9.0,<5.0.0",
     ],
     include_package_data=True,
 )

{hydra_optuna_sweeper-1.4.0.dev4 → hydra_optuna_sweeper-1.4.0.dev6}/tests/test_optuna_sweeper_plugin.py

@@ -8,6 +8,7 @@ from typing import Any, List, Optional
 import optuna
 from hydra.core.override_parser.overrides_parser import OverridesParser
 from hydra.core.plugins import Plugins
+from hydra.errors import InstantiationException
 from hydra.plugins.sweeper import Sweeper
 from hydra.test_utils.test_utils import (
     TSweepRunner,
@@ -15,22 +16,20 @@ from hydra.test_utils.test_utils import (
     run_process,
     run_python_script,
 )
+from hydra.utils import instantiate
 from omegaconf import DictConfig, OmegaConf
 from optuna.distributions import (
     BaseDistribution,
     CategoricalDistribution,
-    DiscreteUniformDistribution,
-    IntLogUniformDistribution,
-    IntUniformDistribution,
-    LogUniformDistribution,
-    UniformDistribution,
+    FloatDistribution,
+    IntDistribution,
 )
 from optuna.samplers import RandomSampler
-from pytest import mark, warns
+from pytest import mark, raises, warns
 
 from hydra_plugins.hydra_optuna_sweeper import _impl
 from hydra_plugins.hydra_optuna_sweeper._impl import OptunaSweeperImpl
-from hydra_plugins.hydra_optuna_sweeper.config import Direction
+from hydra_plugins.hydra_optuna_sweeper.config import Direction, MOTPESamplerConfig
 from hydra_plugins.hydra_optuna_sweeper.optuna_sweeper import OptunaSweeper
 
 chdir_plugin_root()
@@ -68,24 +67,24 @@ def check_distribution(expected: BaseDistribution, actual: BaseDistribution) ->
             {"type": "categorical", "choices": [1, 2, 3]},
             CategoricalDistribution([1, 2, 3]),
         ),
-        ({"type": "int", "low": 0, "high": 10}, IntUniformDistribution(0, 10)),
+        ({"type": "int", "low": 0, "high": 10}, IntDistribution(0, 10)),
         (
             {"type": "int", "low": 0, "high": 10, "step": 2},
-            IntUniformDistribution(0, 10, step=2),
+            IntDistribution(0, 10, step=2),
         ),
-        ({"type": "int", "low": 0, "high": 5}, IntUniformDistribution(0, 5)),
+        ({"type": "int", "low": 0, "high": 5}, IntDistribution(0, 5)),
         (
             {"type": "int", "low": 1, "high": 100, "log": True},
-            IntLogUniformDistribution(1, 100),
+            IntDistribution(1, 100, log=True),
         ),
-        ({"type": "float", "low": 0, "high": 1}, UniformDistribution(0, 1)),
+        ({"type": "float", "low": 0, "high": 1}, FloatDistribution(0, 1)),
         (
             {"type": "float", "low": 0, "high": 10, "step": 2},
-            DiscreteUniformDistribution(0, 10, 2),
+            FloatDistribution(0, 10, step=2),
         ),
         (
             {"type": "float", "low": 1, "high": 100, "log": True},
-            LogUniformDistribution(1, 100),
+            FloatDistribution(1, 100, log=True),
         ),
     ],
 )
@@ -101,12 +100,12 @@ def test_create_optuna_distribution_from_config(input: Any, expected: Any) -> No
         ("key=choice(true, false)", CategoricalDistribution([True, False])),
         ("key=choice('hello', 'world')", CategoricalDistribution(["hello", "world"])),
         ("key=shuffle(range(1,3))", CategoricalDistribution((1, 2))),
-        ("key=range(1,3)", IntUniformDistribution(1, 3)),
-        ("key=interval(1, 5)", UniformDistribution(1, 5)),
-        ("key=int(interval(1, 5))", IntUniformDistribution(1, 5)),
-        ("key=tag(log, interval(1, 5))", LogUniformDistribution(1, 5)),
-        ("key=tag(log, int(interval(1, 5)))", IntLogUniformDistribution(1, 5)),
-        ("key=range(0.5, 5.5, step=1)", DiscreteUniformDistribution(0.5, 5.5, 1)),
+        ("key=range(1,3)", IntDistribution(1, 3)),
+        ("key=interval(1, 5)", FloatDistribution(1, 5)),
+        ("key=int(interval(1, 5))", IntDistribution(1, 5)),
+        ("key=tag(log, interval(1, 5))", FloatDistribution(1, 5, log=True)),
+        ("key=tag(log, int(interval(1, 5)))", IntDistribution(1, 5, log=True)),
+        ("key=range(0.5, 5.5, step=1)", FloatDistribution(0.5, 5.5, step=1)),
     ],
 )
 def test_create_optuna_distribution_from_override(input: Any, expected: Any) -> None:
@@ -119,22 +118,25 @@ def test_create_optuna_distribution_from_override(input: Any, expected: Any) ->
 @mark.parametrize(
     "input, expected",
     [
-        (["key=choice(1,2)"], ({"key": CategoricalDistribution([1, 2])}, {})),
-        (["key=5"], ({}, {"key": "5"})),
+        (["key=choice(1,2)"], ({"key": CategoricalDistribution([1, 2])}, {}, [])),
+        (["key=5"], ({}, {"key": "5"}, [])),
         (
             ["key1=choice(1,2)", "key2=5"],
-            ({"key1": CategoricalDistribution([1, 2])}, {"key2": "5"}),
+            ({"key1": CategoricalDistribution([1, 2])}, {"key2": "5"}, []),
         ),
         (
             ["key1=choice(1,2)", "key2=5", "key3=range(1,3)"],
             (
                 {
                     "key1": CategoricalDistribution([1, 2]),
-                    "key3": IntUniformDistribution(1, 3),
+                    "key3": IntDistribution(1, 3),
                 },
                 {"key2": "5"},
+                [],
             ),
         ),
+        (["~z"], ({}, {}, ["~z"])),
+        (["~z=10"], ({}, {}, ["~z=10"])),
     ],
 )
 def test_create_params_from_overrides(input: Any, expected: Any) -> None:
@@ -380,23 +382,28 @@ def test_failure_rate(max_failure_rate: float, tmpdir: Path) -> None:
         assert error_string not in err
 
 
-def test_example_with_deprecated_search_space(
+def test_motpe_sampler_removed() -> None:
+    with raises(
+        InstantiationException,
+        match="The 'motpe' sampler was removed in Optuna 4.0",
+    ):
+        instantiate(OmegaConf.structured(MOTPESamplerConfig))
+
+
+def test_example_with_removed_motpe(
     tmpdir: Path,
 ) -> None:
     cmd = [
-        "-W ignore::UserWarning",
-        "example/sphere.py",
+        sys.executable,
+        "example/multi-objective.py",
         "--multirun",
         "--config-dir=tests/conf",
-        "--config-name=test_deprecated_search_space",
+        "--config-name=test_motpe",
         "hydra.sweep.dir=" + str(tmpdir),
         "hydra.job.chdir=True",
         "hydra.sweeper.n_trials=20",
         "hydra.sweeper.n_jobs=1",
     ]
 
-    run_optuna_script(cmd)
-    returns = OmegaConf.load(f"{tmpdir}/optimization_results.yaml")
-    assert isinstance(returns, DictConfig)
-    assert returns.name == "optuna"
-    assert abs(returns["best_params"]["x"]) <= 5.5
+    out, err = run_process(cmd, print_error=False, raise_exception=False)
+    assert "The 'motpe' sampler was removed in Optuna 4.0" in err

hydra_optuna_sweeper-1.4.0.dev4/hydra_optuna_sweeper.egg-info/requires.txt

@@ -1,3 +0,0 @@
-hydra-core>=1.1.0.dev7
-optuna<3.0.0,>=2.10.0
-sqlalchemy~=1.3.0