def _adjust_discrete_uniform_high(name, low, high, q):
# type: (str, float, float, float) -> float
d_high = decimal.Decimal(str(high))
d_low = decimal.Decimal(str(low))
d_q = decimal.Decimal(str(q))
d_r = d_high - d_low
if d_r % d_q != decimal.Decimal('0'):
high = float((d_r // d_q) * d_q + d_low)
logger = logging.get_logger(__name__)
logger.warning('The range of parameter `{}` is not divisible by `q`, and is '
'replaced by [{}, {}].'.format(name, low, high))
return high
def __init__(
self,
study, # type: Study
trial_id, # type: int
):
# type: (...) -> None
self.study = study
self._trial_id = trial_id
# TODO(Yanase): Remove _study_id attribute, and use study._study_id instead.
self._study_id = self.study._study_id
self.storage = self.study._storage
self.logger = logging.get_logger(__name__)
self._init_relative_params()
def __init__(
self,
study_name, # type: str
storage, # type: Union[str, storages.BaseStorage]
sampler=None, # type: samplers.BaseSampler
pruner=None, # type: pruners.BasePruner
):
# type: (...) -> None
self.study_name = study_name
self.storage = storages.get_storage(storage)
self.sampler = sampler or samplers.TPESampler()
self.pruner = pruner or pruners.MedianPruner()
self.study_id = self.storage.get_study_id_from_name(study_name)
self.logger = logging.get_logger(__name__)
def product_search_space(study):
# type: (BaseStudy) -> Dict[str, BaseDistribution]
"""Return the product search space of the :class:`~optuna.study.BaseStudy`.
.. deprecated:: 0.14.0
Please use :func:`~optuna.samplers.intersection_search_space` instead.
"""
warnings.warn(
'`product_search_space` function is deprecated. '
'Please use `intersection_search_space` function instead.',
DeprecationWarning)
logger = logging.get_logger(__name__)
logger.warning('`product_search_space` function is deprecated. '
'Please use `intersection_search_space` function instead.')
return intersection_search_space(study)
def __init__(
self,
study, # type: Study
trial_id, # type: int
):
# type: (...) -> None
self.study = study
self._trial_id = trial_id
# TODO(Yanase): Remove _study_id attribute, and use study._study_id instead.
self._study_id = self.study._study_id
self.storage = self.study._storage
self.logger = logging.get_logger(__name__)
self._init_relative_params()
# store all seen distributions in trial to check for consistency
# see: _check_distribution function
self._distributions_in_trial = {} # type: Dict[str, Dict[str, Any]]
def __init__(self, url, connect_args=None):
# type: (str, Optional[Dict[str, Any]]) -> None
connect_args = connect_args or {}
url = self._fill_storage_url_template(url)
try:
self.engine = create_engine(url, connect_args=connect_args)
except ImportError as e:
raise ImportError(
'Failed to import DB access module for the specified storage URL. '
'Please install appropriate one. (The actual import error is: '
+ str(e) + '.)')
self.scoped_session = orm.scoped_session(
orm.sessionmaker(bind=self.engine))
models.BaseModel.metadata.create_all(self.engine)
self._check_table_schema_compatibility()
self.logger = logging.get_logger(__name__)
def __init__(
self,
study_name, # type: str
storage, # type: Union[str, storages.BaseStorage]
sampler=None, # type: samplers.BaseSampler
pruner=None # type: pruners.BasePruner
):
# type: (...) -> None
self.study_name = study_name
storage = storages.get_storage(storage)
study_id = storage.get_study_id_from_name(study_name)
super(Study, self).__init__(study_id, storage)
self.sampler = sampler or samplers.TPESampler()
self.pruner = pruner or pruners.MedianPruner()
self.logger = logging.get_logger(__name__)
self._optimize_lock = threading.Lock()
def study_id(self):
# type: () -> int
"""Return the study ID.
.. deprecated:: 0.20.0
The direct use of this attribute is deprecated and it is recommended that you use
:attr:`~optuna.structs.StudySummary.study_name` instead.
Returns:
The study ID.
"""
message = 'The use of `StudySummary.study_id` is deprecated. ' \
'Please use `StudySummary.study_name` instead.'
warnings.warn(message, DeprecationWarning)
logger = logging.get_logger(__name__)
logger.warning(message)
return self._study_id
def trial_id(self):
# type: () -> int
"""Return the trial ID.
.. deprecated:: 0.19.0
The direct use of this attribute is deprecated and it is recommended that you use
:attr:`~optuna.trial.FrozenTrial.number` instead.
Returns:
The trial ID.
"""
warnings.warn(
'The use of `FrozenTrial.trial_id` is deprecated. '
'Please use `FrozenTrial.number` instead.', DeprecationWarning)
logger = logging.get_logger(__name__)
logger.warning('The use of `FrozenTrial.trial_id` is deprecated. '
'Please use `FrozenTrial.number` instead.')
return self._trial_id
def storage(self):
# type: () -> storages.BaseStorage
"""Return the storage object used by the study.
.. deprecated:: 0.15.0
The direct use of storage is deprecated.
Please access to storage via study's public methods
(e.g., :meth:`~optuna.study.Study.set_user_attr`).
Returns:
A storage object.
"""
warnings.warn(
"The direct use of storage is deprecated. "
"Please access to storage via study's public methods "
"(e.g., `Study.set_user_attr`)", DeprecationWarning)
logger = logging.get_logger(__name__)
logger.warning("The direct use of storage is deprecated. "
"Please access to storage via study's public methods "
"(e.g., `Study.set_user_attr`)")
return self._storage
def __init__(
self,
study, # type: Study
comm, # type: CommunicatorBase
):
# type: (...) -> None
_check_chainermn_availability()
if isinstance(study._storage, InMemoryStorage):
raise ValueError('ChainerMN integration is not available with InMemoryStorage.')
if isinstance(study._storage, RDBStorage):
if study._storage.engine.dialect.name == 'sqlite':
logger = get_logger(__name__)
logger.warning('SQLite may cause synchronization problems when used with '
'ChainerMN integration. Please use other DBs like PostgreSQL.')
study_names = comm.mpi_comm.allgather(study.study_name)
if len(set(study_names)) != 1:
raise ValueError('Please make sure an identical study name is shared among workers.')
super(ChainerMNStudy, self).__setattr__('delegate', study)
super(ChainerMNStudy, self).__setattr__('comm', comm)
import joblib
from joblib import delayed
from joblib import Parallel
import optuna
from optuna import exceptions
from optuna import logging
from optuna import progress_bar as pbar_module
from optuna import storages
from optuna import trial as trial_module
from optuna.trial import FrozenTrial
from optuna.trial import TrialState
_logger = logging.get_logger(__name__)
def _optimize(
study: "optuna.Study",
func: "optuna.study.ObjectiveFuncType",
n_trials: Optional[int] = None,
timeout: Optional[float] = None,
n_jobs: int = 1,
catch: Tuple[Type[Exception], ...] = (),
callbacks: Optional[List[Callable[["optuna.Study", FrozenTrial], None]]] = None,
gc_after_trial: bool = False,
show_progress_bar: bool = False,
) -> None:
if not isinstance(catch, tuple):
raise TypeError(
import plotly
from optuna.visualization._plotly_imports import go
Blues = plotly.colors.sequential.Blues
_distribution_colors = {
UniformDistribution: Blues[-1],
LogUniformDistribution: Blues[-1],
DiscreteUniformDistribution: Blues[-1],
IntUniformDistribution: Blues[-2],
IntLogUniformDistribution: Blues[-2],
CategoricalDistribution: Blues[-4],
}
logger = get_logger(__name__)
def plot_param_importances(
study: Study,
evaluator: Optional[BaseImportanceEvaluator] = None,
params: Optional[List[str]] = None,
*,
target: Optional[Callable[[FrozenTrial], float]] = None,
target_name: str = "Objective Value",
) -> "go.Figure":
"""Plot hyperparameter importances.
Example:
The following code snippet shows how to plot hyperparameter importances.
def __setstate__(self, state):
# type: (Dict[Any, Any]) -> None
self.__dict__.update(state)
self.logger = logging.get_logger(__name__)
def create_study(
storage=None, # type: Union[None, str, storages.BaseStorage]
sampler=None, # type: samplers.BaseSampler
pruner=None, # type: pruners.BasePruner
study_name=None, # type: Optional[str]
direction='minimize', # type: str
load_if_exists=False, # type: bool
force_garbage_collection=True, # type: bool
):
# type: (...) -> Study
"""Create a new :class:`~optuna.study.Study`.
Args:
storage:
Database URL. If this argument is set to None, in-memory storage is used, and the
:class:`~optuna.study.Study` will not be persistent.
sampler:
A sampler object that implements background algorithm for value suggestion.
If :obj:`None` is specified, :class:`~optuna.samplers.TPESampler` is used
as the default. See also :class:`~optuna.samplers`.
pruner:
A pruner object that decides early stopping of unpromising trials. See also
:class:`~optuna.pruners`.
study_name:
Study's name. If this argument is set to None, a unique name is generated
automatically.
direction:
Direction of optimization. Set ``minimize`` for minimization and ``maximize`` for
maximization.
load_if_exists:
Flag to control the behavior to handle a conflict of study names.
In the case where a study named ``study_name`` already exists in the ``storage``,
a :class:`~optuna.structs.DuplicatedStudyError` is raised if ``load_if_exists`` is
set to :obj:`False`.
Otherwise, the creation of the study is skipped, and the existing one is returned.
force_garbage_collection:
Flag to force gc.collect() for every trial.
Returns:
A :class:`~optuna.study.Study` object.
"""
storage = storages.get_storage(storage)
try:
study_id = storage.create_new_study(study_name)
except structs.DuplicatedStudyError:
if load_if_exists:
assert study_name is not None
logger = logging.get_logger(__name__)
logger.info("Using an existing study with name '{}' instead of "
"creating a new one.".format(study_name))
study_id = storage.get_study_id_from_name(study_name)
else:
raise
study_name = storage.get_study_name_from_id(study_id)
study = Study(study_name=study_name,
storage=storage,
sampler=sampler,
pruner=pruner,
force_garbage_collection=force_garbage_collection)
if direction == 'minimize':
_direction = structs.StudyDirection.MINIMIZE
elif direction == 'maximize':
_direction = structs.StudyDirection.MAXIMIZE
else:
raise ValueError(
'Please set either \'minimize\' or \'maximize\' to direction.')
study._storage.set_study_direction(study_id, _direction)
return study
def __setstate__(self, state):
# type: (Dict[Any, Any]) -> None
self.__dict__.update(state)
self.logger = logging.get_logger(__name__)
self._optimize_lock = threading.Lock()
def create_study(
storage=None, # type: Union[None, str, storages.BaseStorage]
sampler=None, # type: samplers.BaseSampler
pruner=None, # type: pruners.BasePruner
study_name=None, # type: Optional[str]
direction='minimize', # type: str
load_if_exists=False, # type: bool
):
# type: (...) -> Study
"""Create a new :class:`~optuna.study.Study`.
Args:
storage:
Database URL. If this argument is set to None, in-memory storage is used, and the
:class:`~optuna.study.Study` will not be persistent.
.. note::
When a database URL is passed, Optuna internally uses `SQLAlchemy`_ to handle
the database. Please refer to `SQLAlchemy's document`_ for further details.
If you want to specify non-default options to `SQLAlchemy Engine`_, you can
instantiate :class:`~optuna.storages.RDBStorage` with your desired options and
pass it to the ``storage`` argument instead of a URL.
.. _SQLAlchemy: https://www.sqlalchemy.org/
.. _SQLAlchemy's document:
https://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls
.. _SQLAlchemy Engine: https://docs.sqlalchemy.org/en/latest/core/engines.html
sampler:
A sampler object that implements background algorithm for value suggestion.
If :obj:`None` is specified, :class:`~optuna.samplers.TPESampler` is used
as the default. See also :class:`~optuna.samplers`.
pruner:
A pruner object that decides early stopping of unpromising trials. See also
:class:`~optuna.pruners`.
study_name:
Study's name. If this argument is set to None, a unique name is generated
automatically.
direction:
Direction of optimization. Set ``minimize`` for minimization and ``maximize`` for
maximization.
load_if_exists:
Flag to control the behavior to handle a conflict of study names.
In the case where a study named ``study_name`` already exists in the ``storage``,
a :class:`~optuna.exceptions.DuplicatedStudyError` is raised if ``load_if_exists`` is
set to :obj:`False`.
Otherwise, the creation of the study is skipped, and the existing one is returned.
Returns:
A :class:`~optuna.study.Study` object.
"""
storage = storages.get_storage(storage)
try:
study_id = storage.create_new_study(study_name)
except exceptions.DuplicatedStudyError:
if load_if_exists:
assert study_name is not None
logger = logging.get_logger(__name__)
logger.info("Using an existing study with name '{}' instead of "
"creating a new one.".format(study_name))
study_id = storage.get_study_id_from_name(study_name)
else:
raise
study_name = storage.get_study_name_from_id(study_id)
study = Study(study_name=study_name,
storage=storage,
sampler=sampler,
pruner=pruner)
if direction == 'minimize':
_direction = structs.StudyDirection.MINIMIZE
elif direction == 'maximize':
_direction = structs.StudyDirection.MAXIMIZE
else:
raise ValueError(
'Please set either \'minimize\' or \'maximize\' to direction.')
study._storage.set_study_direction(study_id, _direction)
return study
