def test_contains():
# type: () -> None
u = distributions.UniformDistribution(low=1., high=2.)
assert not u._contains(0.9)
assert u._contains(1)
assert u._contains(1.5)
assert not u._contains(2)
lu = distributions.LogUniformDistribution(low=0.001, high=100)
assert not lu._contains(0.0)
assert lu._contains(0.001)
assert lu._contains(12.3)
assert not lu._contains(100)
du = distributions.DiscreteUniformDistribution(low=1., high=10., q=2.)
assert not du._contains(0.9)
assert du._contains(1.0)
assert du._contains(3.5)
assert du._contains(6)
assert du._contains(10)
assert not du._contains(10.1)
iu = distributions.IntUniformDistribution(low=1, high=10)
assert not iu._contains(0.9)
assert iu._contains(1)
assert iu._contains(3.5)
assert iu._contains(6)
assert iu._contains(10)
assert iu._contains(10.1)
assert not iu._contains(11)
c = distributions.CategoricalDistribution(choices=('Roppongi', 'Azabu'))
assert not c._contains(-1)
assert c._contains(0)
assert c._contains(1)
assert c._contains(1.5)
assert not c._contains(3)
def suggest_int(self, name, low, high):
# type: (str, int, int) -> int
"""Suggest a value for the integer parameter.
The value is sampled from the integers in :math:`[\\mathsf{low}, \\mathsf{high}]`.
Example:
Suggest the number of trees in `RandomForestClassifier <https://scikit-learn.org/
stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html>`_.
.. code::
>>> def objective(trial):
>>> ...
>>> n_estimators = trial.suggest_int('n_estimators', 50, 400)
>>> clf = sklearn.ensemble.RandomForestClassifier(n_estimators=n_estimators)
>>> ...
Args:
name:
A parameter name.
low:
Lower endpoint of the range of suggested values. ``low`` is included in the range.
high:
Upper endpoint of the range of suggested values. ``high`` is included in the range.
Returns:
A suggested integer value.
"""
distribution = distributions.IntUniformDistribution(low=low, high=high)
if low == high:
param_value_in_internal_repr = distribution.to_internal_repr(low)
return self._set_new_param_or_get_existing(
name, param_value_in_internal_repr, distribution)
return int(self._suggest(name, distribution))
def test_distributions(storage_init_func):
# type: (typing.Callable[[], storages.BaseStorage]) -> None
def objective(trial):
# type: (Trial) -> float
trial.suggest_uniform('a', 0, 10)
trial.suggest_loguniform('b', 0.1, 10)
trial.suggest_discrete_uniform('c', 0, 10, 1)
trial.suggest_int('d', 0, 10)
trial.suggest_categorical('e', ['foo', 'bar', 'baz'])
return 1.0
study = create_study(storage_init_func())
study.optimize(objective, n_trials=1)
assert study.best_trial.distributions == {
'a': distributions.UniformDistribution(low=0, high=10),
'b': distributions.LogUniformDistribution(low=0.1, high=10),
'c': distributions.DiscreteUniformDistribution(low=0, high=10, q=1),
'd': distributions.IntUniformDistribution(low=0, high=10),
'e': distributions.CategoricalDistribution(choices=('foo', 'bar', 'baz'))
}
def test_distributions(storage_init_func):
# type: (typing.Callable[[], storages.BaseStorage]) -> None
def objective(trial):
# type: (Trial) -> float
trial.suggest_uniform("a", 0, 10)
trial.suggest_loguniform("b", 0.1, 10)
trial.suggest_discrete_uniform("c", 0, 10, 1)
trial.suggest_int("d", 0, 10)
trial.suggest_categorical("e", ["foo", "bar", "baz"])
return 1.0
study = create_study(storage_init_func())
study.optimize(objective, n_trials=1)
assert study.best_trial.distributions == {
"a": distributions.UniformDistribution(low=0, high=10),
"b": distributions.LogUniformDistribution(low=0.1, high=10),
"c": distributions.DiscreteUniformDistribution(low=0, high=10, q=1),
"d": distributions.IntUniformDistribution(low=0, high=10),
"e": distributions.CategoricalDistribution(choices=("foo", "bar", "baz")),
}
def suggest_int(self, name, low, high):
# type: (str, int, int) -> int
return int(self._suggest(name, distributions.IntUniformDistribution(low=low, high=high)))
def test_backward_compatibility_int_uniform_distribution() -> None:
json_str = '{"name": "IntUniformDistribution", "attributes": {"low": 1, "high": 10}}'
actual = distributions.json_to_distribution(json_str)
expected = distributions.IntUniformDistribution(low=1, high=10)
assert actual == expected
def test_contains() -> None:
u = distributions.UniformDistribution(low=1.0, high=2.0)
assert not u._contains(0.9)
assert u._contains(1)
assert u._contains(1.5)
assert not u._contains(2)
lu = distributions.LogUniformDistribution(low=0.001, high=100)
assert not lu._contains(0.0)
assert lu._contains(0.001)
assert lu._contains(12.3)
assert not lu._contains(100)
with warnings.catch_warnings():
# UserWarning will be raised since the range is not divisible by 2.
# The range will be replaced with [1.0, 9.0].
warnings.simplefilter("ignore", category=UserWarning)
du = distributions.DiscreteUniformDistribution(low=1.0,
high=10.0,
q=2.0)
assert not du._contains(0.9)
assert du._contains(1.0)
assert du._contains(3.5)
assert du._contains(6)
assert du._contains(9)
assert not du._contains(9.1)
assert not du._contains(10)
iu = distributions.IntUniformDistribution(low=1, high=10)
assert not iu._contains(0.9)
assert iu._contains(1)
assert iu._contains(4)
assert iu._contains(6)
assert iu._contains(10)
assert not iu._contains(10.1)
assert not iu._contains(11)
# IntUniformDistribution with a 'step' parameter.
with warnings.catch_warnings():
# UserWarning will be raised since the range is not divisible by 2.
# The range will be replaced with [1, 9].
warnings.simplefilter("ignore", category=UserWarning)
iuq = distributions.IntUniformDistribution(low=1, high=10, step=2)
assert not iuq._contains(0.9)
assert iuq._contains(1)
assert iuq._contains(4)
assert iuq._contains(6)
assert iuq._contains(9)
assert not iuq._contains(9.1)
assert not iuq._contains(10)
c = distributions.CategoricalDistribution(choices=("Roppongi", "Azabu"))
assert not c._contains(-1)
assert c._contains(0)
assert c._contains(1)
assert c._contains(1.5)
assert not c._contains(3)
ilu = distributions.IntUniformDistribution(low=2, high=12)
assert not ilu._contains(0.9)
assert ilu._contains(2)
assert ilu._contains(4)
assert ilu._contains(6)
assert ilu._contains(12)
assert not ilu._contains(12.1)
assert not ilu._contains(13)
iluq = distributions.IntLogUniformDistribution(low=2, high=7)
assert not iluq._contains(0.9)
assert iluq._contains(2)
assert iluq._contains(4)
assert iluq._contains(5)
assert iluq._contains(6)
assert not iluq._contains(7.1)
assert not iluq._contains(8)
import copy
import json
from typing import Any
from typing import Dict
from typing import List
import warnings
import pytest
from optuna import distributions
EXAMPLE_DISTRIBUTIONS = {
"u": distributions.UniformDistribution(low=1.0, high=2.0),
"l": distributions.LogUniformDistribution(low=0.001, high=100),
"du": distributions.DiscreteUniformDistribution(low=1.0, high=9.0, q=2.0),
"iu": distributions.IntUniformDistribution(low=1, high=9, step=2),
"c1": distributions.CategoricalDistribution(choices=(2.71, -float("inf"))),
"c2": distributions.CategoricalDistribution(choices=("Roppongi", "Azabu")),
"c3": distributions.CategoricalDistribution(choices=["Roppongi", "Azabu"]),
"ilu": distributions.IntLogUniformDistribution(low=2, high=12, step=2),
} # type: Dict[str, Any]
EXAMPLE_JSONS = {
"u":
'{"name": "UniformDistribution", "attributes": {"low": 1.0, "high": 2.0}}',
"l":
'{"name": "LogUniformDistribution", "attributes": {"low": 0.001, "high": 100}}',
"du":
'{"name": "DiscreteUniformDistribution",'
'"attributes": {"low": 1.0, "high": 9.0, "q": 2.0}}',
"iu":
import pytest
from optuna import distributions
from optuna import type_checking
if type_checking.TYPE_CHECKING:
from typing import Any # NOQA
from typing import Dict # NOQA
from typing import List # NOQA
EXAMPLE_DISTRIBUTIONS = {
'u': distributions.UniformDistribution(low=1., high=2.),
'l': distributions.LogUniformDistribution(low=0.001, high=100),
'du': distributions.DiscreteUniformDistribution(low=1., high=10., q=2.),
'iu': distributions.IntUniformDistribution(low=1, high=10),
'c1': distributions.CategoricalDistribution(choices=(2.71, -float('inf'))),
'c2': distributions.CategoricalDistribution(choices=('Roppongi', 'Azabu'))
} # type: Dict[str, Any]
EXAMPLE_JSONS = {
'u': '{"name": "UniformDistribution", "attributes": {"low": 1.0, "high": 2.0}}',
'l': '{"name": "LogUniformDistribution", "attributes": {"low": 0.001, "high": 100}}',
'du': '{"name": "DiscreteUniformDistribution",'
'"attributes": {"low": 1.0, "high": 10.0, "q": 2.0}}',
'iu': '{"name": "IntUniformDistribution", "attributes": {"low": 1, "high": 10}}',
'c1': '{"name": "CategoricalDistribution", "attributes": {"choices": [2.71, -Infinity]}}',
'c2': '{"name": "CategoricalDistribution", "attributes": {"choices": ["Roppongi", "Azabu"]}}'
}
from typing import List
from unittest.mock import patch
import numpy as np
import pytest
from optuna import distributions
from optuna.samplers._tpe.parzen_estimator import _ParzenEstimator
from optuna.samplers._tpe.parzen_estimator import _ParzenEstimatorParameters
from optuna.samplers._tpe.sampler import default_weights
SEARCH_SPACE = {
"a": distributions.UniformDistribution(1.0, 100.0),
"b": distributions.LogUniformDistribution(1.0, 100.0),
"c": distributions.DiscreteUniformDistribution(1.0, 100.0, 3.0),
"d": distributions.IntUniformDistribution(1, 100),
"e": distributions.IntLogUniformDistribution(1, 100),
"f": distributions.CategoricalDistribution(["x", "y", "z"]),
}
MULTIVARIATE_SAMPLES = {
"a": np.array([1.0]),
"b": np.array([1.0]),
"c": np.array([1.0]),
"d": np.array([1]),
"e": np.array([1]),
"f": np.array([1]),
}
_PRECOMPUTE_SIGMAS0 = "optuna.samplers._tpe.parzen_estimator._ParzenEstimator._precompute_sigmas0"
def test_group() -> None:
with warnings.catch_warnings():
warnings.simplefilter("ignore", optuna.exceptions.ExperimentalWarning)
sampler = TPESampler(multivariate=True, group=True)
study = optuna.create_study(sampler=sampler)
with patch.object(sampler, "_sample_relative", wraps=sampler._sample_relative) as mock:
study.optimize(lambda t: t.suggest_int("x", 0, 10), n_trials=2)
assert mock.call_count == 1
assert study.trials[-1].distributions == {
"x": distributions.IntUniformDistribution(low=0, high=10)
}
with patch.object(sampler, "_sample_relative", wraps=sampler._sample_relative) as mock:
study.optimize(
lambda t: t.suggest_int("y", 0, 10) + t.suggest_float("z", -3, 3), n_trials=1
)
assert mock.call_count == 1
assert study.trials[-1].distributions == {
"y": distributions.IntUniformDistribution(low=0, high=10),
"z": distributions.UniformDistribution(low=-3, high=3),
}
with patch.object(sampler, "_sample_relative", wraps=sampler._sample_relative) as mock:
study.optimize(
lambda t: t.suggest_int("y", 0, 10)
+ t.suggest_float("z", -3, 3)
+ t.suggest_float("u", 1e-2, 1e2, log=True)
+ bool(t.suggest_categorical("v", ["A", "B", "C"])),
n_trials=1,
)
assert mock.call_count == 2
assert study.trials[-1].distributions == {
"u": distributions.LogUniformDistribution(low=1e-2, high=1e2),
"v": distributions.CategoricalDistribution(choices=["A", "B", "C"]),
"y": distributions.IntUniformDistribution(low=0, high=10),
"z": distributions.UniformDistribution(low=-3, high=3),
}
with patch.object(sampler, "_sample_relative", wraps=sampler._sample_relative) as mock:
study.optimize(lambda t: t.suggest_float("u", 1e-2, 1e2, log=True), n_trials=1)
assert mock.call_count == 3
assert study.trials[-1].distributions == {
"u": distributions.LogUniformDistribution(low=1e-2, high=1e2)
}
with patch.object(sampler, "_sample_relative", wraps=sampler._sample_relative) as mock:
study.optimize(
lambda t: t.suggest_int("y", 0, 10) + t.suggest_int("w", 2, 8, log=True), n_trials=1
)
assert mock.call_count == 4
assert study.trials[-1].distributions == {
"y": distributions.IntUniformDistribution(low=0, high=10),
"w": distributions.IntLogUniformDistribution(low=2, high=8),
}
with patch.object(sampler, "_sample_relative", wraps=sampler._sample_relative) as mock:
study.optimize(lambda t: t.suggest_int("x", 0, 10), n_trials=1)
assert mock.call_count == 6
assert study.trials[-1].distributions == {
"x": distributions.IntUniformDistribution(low=0, high=10)
}
def test_check_distribution_compatibility() -> None:
# test the same distribution
for key in EXAMPLE_JSONS:
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS[key], EXAMPLE_DISTRIBUTIONS[key])
# test different distribution classes
pytest.raises(
ValueError,
lambda: distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["i"], EXAMPLE_DISTRIBUTIONS["fl"]),
)
pytest.raises(
ValueError,
lambda: distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["u"], EXAMPLE_DISTRIBUTIONS["l"]),
)
# test compatibility between IntDistributions.
distributions.check_distribution_compatibility(EXAMPLE_DISTRIBUTIONS["i"],
EXAMPLE_DISTRIBUTIONS["il"])
distributions.check_distribution_compatibility(EXAMPLE_DISTRIBUTIONS["il"],
EXAMPLE_DISTRIBUTIONS["id"])
distributions.check_distribution_compatibility(EXAMPLE_DISTRIBUTIONS["id"],
EXAMPLE_DISTRIBUTIONS["i"])
# test compatibility between FloatDistributions.
distributions.check_distribution_compatibility(EXAMPLE_DISTRIBUTIONS["f"],
EXAMPLE_DISTRIBUTIONS["fl"])
distributions.check_distribution_compatibility(EXAMPLE_DISTRIBUTIONS["fl"],
EXAMPLE_DISTRIBUTIONS["fd"])
distributions.check_distribution_compatibility(EXAMPLE_DISTRIBUTIONS["fd"],
EXAMPLE_DISTRIBUTIONS["f"])
# test dynamic value range (CategoricalDistribution)
pytest.raises(
ValueError,
lambda: distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["c2"],
distributions.CategoricalDistribution(choices=("Roppongi",
"Akasaka")),
),
)
# test dynamic value range (except CategoricalDistribution)
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["i"],
distributions.IntDistribution(low=-3, high=2))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["il"],
distributions.IntDistribution(low=1, high=13, log=True))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["id"],
distributions.IntDistribution(low=-3, high=2, step=2))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["f"],
distributions.FloatDistribution(low=-3.0, high=-2.0))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["fl"],
distributions.FloatDistribution(low=0.1, high=1.0, log=True))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["fd"],
distributions.FloatDistribution(low=-1.0, high=11.0, step=0.5))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["u"],
distributions.UniformDistribution(low=-3.0, high=-2.0))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["l"],
distributions.LogUniformDistribution(low=0.1, high=1.0))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["du"],
distributions.DiscreteUniformDistribution(low=-1.0, high=11.0, q=3.0),
)
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["iu"],
distributions.IntUniformDistribution(low=-1, high=1))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["iuq"],
distributions.IntUniformDistribution(low=-1, high=1))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["ilu"],
distributions.IntLogUniformDistribution(low=1, high=13))
distributions.check_distribution_compatibility(
EXAMPLE_DISTRIBUTIONS["iluq"],
distributions.IntLogUniformDistribution(low=1, high=13))
def suggest_int(self, name, low, high, step=1):
# type: (str, int, int, int) -> int
sample = self._suggest(
name, distributions.IntUniformDistribution(low=low, high=high, step=step)
)
return int(sample)
