def __init__(self, f, pbounds, random_state=None, verbose=2):
"""
this is a comment
"""
self._random_state = ensure_rng(random_state)
# Data structure containing the function to be optimized, the bounds of
# its domain, and a record of the evaluations we have done so far
self._space = TargetSpace(f, pbounds, random_state)
# queue
self._queue = Queue()
# Internal GP regressor
self._gp = GaussianProcessRegressor(
kernel=Matern(nu=2.5),
alpha=1e-6,
normalize_y=True,
n_restarts_optimizer=1,
random_state=self._random_state,
#optimizer=None
)
self._verbose = verbose
super(BayesianOptimization, self).__init__(events=DEFAULT_EVENTS)
def __init__(self, target_func, pbounds, random_state=None):
"""
Parameters
----------
target_func : function
Function to be maximized.
pbounds : dict
Dictionary with parameters names as keys and a tuple with minimum
and maximum values.
random_state : int, RandomState, or None
optionally specify a seed for a random number generator
"""
self.random_state = ensure_rng(random_state)
# The function to be optimized
self.target_func = target_func
# Get the name of the parameters
self._keys = sorted(pbounds)
# Create an array with parameters bounds
self._bounds = np.array(
[item[1] for item in sorted(pbounds.items(), key=lambda x: x[0])],
dtype=np.float)
# preallocated memory for X and Y points
self._params = np.empty(shape=(0, self.dim))
self._target = np.empty(shape=(0))
# keep track of unique points we have seen so far
self._cache = {}
def __init__(self, f, pbounds, random_state=None, verbose=2, constraints=[]):
""""""
self._random_state = ensure_rng(random_state)
# Data structure containing the function to be optimized, the bounds of
# its domain, and a record of the evaluations we have done so far
self._space = TargetSpace(f, pbounds, random_state)
# queue
self._queue = Queue()
# Internal GP regressor
self._gp = GaussianProcessRegressor(
kernel=Matern(nu=2.5),
alpha=3e-3,
normalize_y=True,
n_restarts_optimizer=25,
random_state=self._random_state,
)
self._verbose = verbose
# Key constraints correspond to literal keyword names
# array constraints correspond to point in array row
self._key_constraints = constraints
self._array_constraints = self.array_like_constraints()
super(BayesianOptimization, self).__init__(events=DEFAULT_EVENTS)
def __init__(self,
f,
pbounds,
random_state=None,
verbose=2,
bounds_transformer=None):
self._random_state = ensure_rng(random_state)
# Data structure containing the function to be optimized, the bounds of
# its domain, and a record of the evaluations we have done so far
self._space = TargetSpace(f, pbounds, random_state)
self._queue = Queue()
# Internal GP regressor
self._gp = GaussianProcessRegressor(
kernel=Matern(nu=2.5),
alpha=1e-6,
normalize_y=True,
n_restarts_optimizer=5,
random_state=self._random_state,
)
self._verbose = verbose
self._bounds_transformer = bounds_transformer
if self._bounds_transformer:
try:
self._bounds_transformer.initialize(self._space)
except (AttributeError, TypeError):
raise TypeError('The transformer must be an instance of '
'DomainTransformer')
super(BayesianOptimization, self).__init__(events=DEFAULT_EVENTS)
def __init__(self, target_func, prange, random_state=None):
"""
Parameters
----------
target_func : function
Function to be maximized.
pbounds : dict
Dictionary with parameters names as keys and a tuple with minimum
maximum, and step values.
random_state : int, RandomState, or None
optionally specify a seed for a random number generator
"""
self.random_state = ensure_rng(random_state)
# The function to be optimized
self.target_func = target_func
# Get the name of the parameters
self._keys = sorted(prange)
# Get associated pbounds for TargetSpace()
self._pbounds = {item[0] :(item[1][:2]) for item in sorted(prange.items(), key=lambda x: x[0])}
# Create an array with parameters steps
self._steps = np.array(
[item[1][-1] for item in sorted(prange.items(), key=lambda x: x[0])],
dtype=np.float
)
# keep track of unique points we have seen so far
self._discrete_cache = {}
super(DiscreteSpace, self).__init__(target_func=target_func,
pbounds=self._pbounds,
random_state=random_state)
def reset_rng(self, random_state=None):
self._random_state = ensure_rng(random_state)