def execute_pygpgo(params, problem, max_eval, log):
from solvers.pyGPGO.wpyGPGO import optimize_pyGPGO
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
rand_evals = int(params['--rand-evals'])
# TODO: Allow picking different values for these?
cov = matern32()
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ExpectedImprovement')
return optimize_pyGPGO(problem,
max_eval,
gp,
acq,
random_init_evals=rand_evals,
log=log)
X, Y = np.meshgrid(X, Y)
ax = fig.add_subplot(1, 2, 2, projection='3d')
ax.set_title('Gaussian Process surrogate')
surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,
linewidth=0)
fig.colorbar(surf, shrink=0.5, aspect=5)
best = gpgo.best
ax.scatter([best[0]], [best[1]], s=40, marker='x', c='r', label='Sampled point')
plt.legend(loc='lower right')
#plt.show()
return Z
if __name__ == '__main__':
n_iter = 10
cov = matern32()
gp = GaussianProcess(cov)
acq = Acquisition(mode='ExpectedImprovement')
param = {'x': ('cont', [0, 1]),
'y': ('cont', [0, 1])}
np.random.seed(85)
gpgo = GPGO(gp, acq, f, param)
gpgo.run(max_iter=1)
for i in range(n_iter):
fig = plt.figure(figsize=plt.figaspect(0.5))
fig.suptitle("Franke's function (Iteration {})".format(i+1))
gpgo.run(max_iter=1, resume=True)
plotFranke()
plotPred(gpgo)
def hyperparam_search( # type: ignore[override]
self,
params_dict: PARAM_DICT,
train_dataset: Dataset,
valid_dataset: Dataset,
metric: Metric,
use_max: bool = True,
logdir: Optional[str] = None,
max_iter: int = 20,
search_range: Union[int, float, PARAM_DICT] = 4,
logfile: Optional[str] = None):
"""Perform hyperparameter search using a gaussian process.
Parameters
----------
params_dict : Dict
Maps hyperparameter names (strings) to possible parameter
values. The semantics of this list are different than for
`GridHyperparamOpt`. `params_dict[hp]` must map to an int/float,
which is used as the center of a search with radius
`search_range` since pyGPGO can only optimize numerical
hyperparameters.
train_dataset : Dataset
dataset used for training
valid_dataset : Dataset
dataset used for validation(optimization on valid scores)
metric : Metric
metric used for evaluation
use_max : bool, (default True)
Specifies whether to maximize or minimize `metric`.
maximization(True) or minimization(False)
logdir : str, optional, (default None)
The directory in which to store created models. If not set, will
use a temporary directory.
max_iter : int, (default 20)
number of optimization trials
search_range : int/float/Dict (default 4)
The `search_range` specifies the range of parameter values to
search for. If `search_range` is an int/float, it is used as the
global search range for parameters. This creates a search
problem on the following space:
optimization on [initial value / search_range,
initial value * search_range]
If `search_range` is a dict, it must contain the same keys as
for `params_dict`. In this case, `search_range` specifies a
per-parameter search range. This is useful in case some
parameters have a larger natural range than others. For a given
hyperparameter `hp` this would create the following search
range:
optimization on hp on [initial value[hp] / search_range[hp],
initial value[hp] * search_range[hp]]
logfile : str, optional (default None)
Name of logfile to write results to. If specified, this is must
be a valid file. If not specified, results of hyperparameter
search will be written to `logdir/.txt`.
Returns
-------
Tuple[`best_model`, `best_hyperparams`, `all_scores`]
`(best_model, best_hyperparams, all_scores)` where `best_model` is
an instance of `dc.model.Model`, `best_hyperparams` is a
dictionary of parameters, and `all_scores` is a dictionary mapping
string representations of hyperparameter sets to validation
scores.
"""
try:
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
except ModuleNotFoundError:
raise ValueError("This class requires pyGPGO to be installed.")
# Specify logfile
log_file = None
if logfile:
log_file = logfile
elif logdir is not None:
# Make logdir if it doesn't exist.
if not os.path.exists(logdir):
os.makedirs(logdir, exist_ok=True)
log_file = os.path.join(logdir, "results.txt")
# setup range
param_range = compute_parameter_range(params_dict, search_range)
param_keys = list(param_range.keys())
# Stores all results
all_results = {}
# Store all model references so we don't have to reload
all_models = {}
# Stores all model locations
model_locations = {}
# Demarcating internal function for readability
def optimizing_function(**placeholders):
"""Private Optimizing function
Take in hyper parameter values and return valid set performances
Parameters
----------
placeholders : keyword arguments
Should be various hyperparameters as specified in `param_keys` above.
Returns:
--------
valid_scores : float
valid set performances
"""
hyper_parameters = {}
for hp in param_keys:
if param_range[hp][0] == "int":
# param values are always float in BO, so this line converts float to int
# see : https://github.com/josejimenezluna/pyGPGO/issues/10
hyper_parameters[hp] = int(placeholders[hp])
else:
hyper_parameters[hp] = float(placeholders[hp])
logger.info("Running hyperparameter set: %s" %
str(hyper_parameters))
if log_file:
with open(log_file, 'w+') as f:
# Record hyperparameters
f.write("Parameters: %s" % str(hyper_parameters))
f.write('\n')
hp_str = _convert_hyperparam_dict_to_filename(hyper_parameters)
if logdir is not None:
filename = "model%s" % hp_str
model_dir = os.path.join(logdir, filename)
logger.info("model_dir is %s" % model_dir)
try:
os.makedirs(model_dir)
except OSError:
if not os.path.isdir(model_dir):
logger.info(
"Error creating model_dir, using tempfile directory"
)
model_dir = tempfile.mkdtemp()
else:
model_dir = tempfile.mkdtemp()
# Add it on to the information needed for the constructor
hyper_parameters["model_dir"] = model_dir
model = self.model_builder(**hyper_parameters)
model.fit(train_dataset)
try:
model.save()
# Some models autosave
except NotImplementedError:
pass
multitask_scores = model.evaluate(valid_dataset, [metric])
score = multitask_scores[metric.name]
if log_file:
with open(log_file, 'a') as f:
# Record performances
f.write("Score: %s" % str(score))
f.write('\n')
# Store all results
all_results[hp_str] = score
# Store reference to model
all_models[hp_str] = model
model_locations[hp_str] = model_dir
# GPGO maximize performance by default
# set performance to its negative value for minimization
if use_max:
return score
else:
return -score
# execute GPGO
cov = matern32()
gp = GaussianProcess(cov)
acq = Acquisition(mode='ExpectedImprovement')
gpgo = GPGO(gp, acq, optimizing_function, param_range)
logger.info("Max number of iteration: %i" % max_iter)
gpgo.run(max_iter=max_iter)
hp_opt, valid_performance_opt = gpgo.getResult()
hyper_parameters = {}
for hp in param_keys:
if param_range[hp][0] == "int":
hyper_parameters[hp] = int(hp_opt[hp])
else:
# FIXME: Incompatible types in assignment
hyper_parameters[hp] = float(hp_opt[hp]) # type: ignore
hp_str = _convert_hyperparam_dict_to_filename(hyper_parameters)
# Let's fetch the model with the best parameters
best_model = all_models[hp_str]
# Compare best model to default hyperparameters
if log_file:
with open(log_file, 'a') as f:
# Record hyperparameters
f.write("params_dict:")
f.write(str(params_dict))
f.write('\n')
# Return default hyperparameters
return best_model, hyper_parameters, all_results
import numpy as np
from pyGPGO.covfunc import squaredExponential, matern, matern32, matern52, \
gammaExponential, rationalQuadratic, expSine, dotProd
covfuncs = [
squaredExponential(),
matern(),
matern32(),
matern52(),
gammaExponential(),
rationalQuadratic(),
expSine(),
dotProd()
]
grad_enabled = [
squaredExponential(),
matern32(),
matern52(),
gammaExponential(),
rationalQuadratic(),
expSine()
]
# Some kernels do not have gradient computation enabled, such is the case
# of the generalised matérn kernel.
#
# All (but the dotProd kernel) have a characteristic length-scale l that
# we test for here.
def hyperparam_search(
self,
params_dict,
train_dataset,
valid_dataset,
output_transformers,
metric,
direction=True,
n_features=1024,
n_tasks=1,
max_iter=20,
search_range=4,
hp_invalid_list=[
'seed', 'nb_epoch', 'penalty_type', 'dropouts',
'bypass_dropouts', 'n_pair_feat', 'fit_transformers',
'min_child_weight', 'max_delta_step', 'subsample',
'colsample_bylevel', 'colsample_bytree', 'reg_alpha',
'reg_lambda', 'scale_pos_weight', 'base_score'
],
log_file='GPhypersearch.log'):
"""Perform hyperparams search using a gaussian process assumption
params_dict include single-valued parameters being optimized,
which should only contain int, float and list of int(float)
parameters with names in hp_invalid_list will not be changed.
For Molnet models, self.model_class is model name in string,
params_dict = dc.molnet.preset_hyper_parameters.hps[self.model_class]
Parameters
----------
params_dict: dict
dict including parameters and their initial values
parameters not suitable for optimization can be added to hp_invalid_list
train_dataset: dc.data.Dataset struct
dataset used for training
valid_dataset: dc.data.Dataset struct
dataset used for validation(optimization on valid scores)
output_transformers: list of dc.trans.Transformer
transformers for evaluation
metric: list of dc.metrics.Metric
metric used for evaluation
direction: bool
maximization(True) or minimization(False)
n_features: int
number of input features
n_tasks: int
number of tasks
max_iter: int
number of optimization trials
search_range: int(float)
optimization on [initial values / search_range,
initial values * search_range]
hp_invalid_list: list
names of parameters that should not be optimized
logfile: string
name of log file, hyperparameters and results for each trial will be recorded
Returns
-------
hyper_parameters: dict
params_dict with all optimized values
valid_performance_opt: float
best performance on valid dataset
"""
assert len(metric) == 1, 'Only use one metric'
hyper_parameters = params_dict
hp_list = hyper_parameters.keys()
for hp in hp_invalid_list:
if hp in hp_list:
hp_list.remove(hp)
hp_list_class = [hyper_parameters[hp].__class__ for hp in hp_list]
assert set(hp_list_class) <= set([list, int, float])
# Float or int hyper parameters(ex. batch_size, learning_rate)
hp_list_single = [
hp_list[i] for i in range(len(hp_list))
if not hp_list_class[i] is list
]
# List of float or int hyper parameters(ex. layer_sizes)
hp_list_multiple = [(hp_list[i], len(hyper_parameters[hp_list[i]]))
for i in range(len(hp_list))
if hp_list_class[i] is list]
# Number of parameters
n_param = len(hp_list_single)
if len(hp_list_multiple) > 0:
n_param = n_param + sum([hp[1] for hp in hp_list_multiple])
# Range of optimization
param_range = []
for hp in hp_list_single:
if hyper_parameters[hp].__class__ is int:
param_range.append((('int'), [
hyper_parameters[hp] // search_range,
hyper_parameters[hp] * search_range
]))
else:
param_range.append((('cont'), [
hyper_parameters[hp] / search_range,
hyper_parameters[hp] * search_range
]))
for hp in hp_list_multiple:
if hyper_parameters[hp[0]][0].__class__ is int:
param_range.extend([(('int'), [
hyper_parameters[hp[0]][i] // search_range,
hyper_parameters[hp[0]][i] * search_range
]) for i in range(hp[1])])
else:
param_range.extend([(('cont'), [
hyper_parameters[hp[0]][i] / search_range,
hyper_parameters[hp[0]][i] * search_range
]) for i in range(hp[1])])
# Dummy names
param_name = ['l' + format(i, '02d') for i in range(20)]
param = dict(zip(param_name[:n_param], param_range))
data_dir = os.environ['DEEPCHEM_DATA_DIR']
log_file = os.path.join(data_dir, log_file)
def f(l00=0,
l01=0,
l02=0,
l03=0,
l04=0,
l05=0,
l06=0,
l07=0,
l08=0,
l09=0,
l10=0,
l11=0,
l12=0,
l13=0,
l14=0,
l15=0,
l16=0,
l17=0,
l18=0,
l19=0):
""" Optimizing function
Take in hyper parameter values and return valid set performances
Parameters
----------
l00~l19: int or float
placeholders for hyperparameters being optimized,
hyper_parameters dict is rebuilt based on input values of placeholders
Returns:
--------
valid_scores: float
valid set performances
"""
args = locals()
# Input hyper parameters
i = 0
for hp in hp_list_single:
hyper_parameters[hp] = float(args[param_name[i]])
if param_range[i][0] == 'int':
hyper_parameters[hp] = int(hyper_parameters[hp])
i = i + 1
for hp in hp_list_multiple:
hyper_parameters[hp[0]] = [
float(args[param_name[j]]) for j in range(i, i + hp[1])
]
if param_range[i][0] == 'int':
hyper_parameters[hp[0]] = map(int, hyper_parameters[hp[0]])
i = i + hp[1]
logger.info(hyper_parameters)
# Run benchmark
with open(log_file, 'a') as f:
# Record hyperparameters
f.write(str(hyper_parameters))
f.write('\n')
if isinstance(self.model_class, str) or isinstance(
self.model_class, unicode):
try:
train_scores, valid_scores, _ = benchmark_classification(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=hyper_parameters)
except AssertionError:
train_scores, valid_scores, _ = benchmark_regression(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=hyper_parameters)
score = valid_scores[self.model_class][metric[0].name]
else:
model_dir = tempfile.mkdtemp()
model = self.model_class(hyper_parameters, model_dir)
model.fit(train_dataset, **hyper_parameters)
model.save()
evaluator = Evaluator(model, valid_dataset,
output_transformers)
multitask_scores = evaluator.compute_model_performance(metric)
score = multitask_scores[metric[0].name]
with open(log_file, 'a') as f:
# Record performances
f.write(str(score))
f.write('\n')
# GPGO maximize performance by default, set performance to its negative value for minimization
if direction:
return score
else:
return -score
import pyGPGO
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
cov = matern32()
gp = GaussianProcess(cov)
acq = Acquisition(mode='ExpectedImprovement')
gpgo = GPGO(gp, acq, f, param)
logger.info("Max number of iteration: %i" % max_iter)
gpgo.run(max_iter=max_iter)
hp_opt, valid_performance_opt = gpgo.getResult()
# Readout best hyper parameters
i = 0
for hp in hp_list_single:
hyper_parameters[hp] = float(hp_opt[param_name[i]])
if param_range[i][0] == 'int':
hyper_parameters[hp] = int(hyper_parameters[hp])
i = i + 1
for hp in hp_list_multiple:
hyper_parameters[hp[0]] = [
float(hp_opt[param_name[j]]) for j in range(i, i + hp[1])
]
if param_range[i][0] == 'int':
hyper_parameters[hp[0]] = map(int, hyper_parameters[hp[0]])
i = i + hp[1]
# Compare best model to default hyperparameters
with open(log_file, 'a') as f:
# Record hyperparameters
f.write(str(params_dict))
f.write('\n')
if isinstance(self.model_class, str) or isinstance(
self.model_class, unicode):
try:
train_scores, valid_scores, _ = benchmark_classification(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=params_dict)
except AssertionError:
train_scores, valid_scores, _ = benchmark_regression(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=params_dict)
score = valid_scores[self.model_class][metric[0].name]
with open(log_file, 'a') as f:
# Record performances
f.write(str(score))
f.write('\n')
if not direction:
score = -score
if score > valid_performance_opt:
# Optimized model is better, return hyperparameters
return params_dict, score
# Return default hyperparameters
return hyper_parameters, valid_performance_opt
#######################################
# pyGPGO examples
# hyperpost: shows posterior distribution of hyperparameters
# for a Gaussian Process example
#######################################
import numpy as np
from pyGPGO.surrogates.GaussianProcessMCMC import GaussianProcessMCMC
from pyGPGO.covfunc import matern32
if __name__ == '__main__':
np.random.seed(1337)
sexp = matern32()
gp = GaussianProcessMCMC(sexp, niter=2000, init='MAP', step=None)
X = np.linspace(0, 6, 7)[:, None]
y = np.sin(X).flatten()
gp.fit(X, y)
gp.posteriorPlot()
def Scan(self):
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
spec.integration_time_micros(100 * 1000)
def scan_f(Z, Y):
l1 = spec.intensities()
print("\n")
print("Before :", int(Y), int(Z), int(positionvalue(5)),
int(positionvalue(6)), int(max(l1)))
#mouve(4, S, 'ABSOL')
mouve(5, Y, 'ABSOL')
mouve(6, Z, 'ABSOL')
if positionvalue(5) != Y and positionvalue(6) != Z:
time.sleep(0.6)
l2 = spec.intensities()
lw = spec.wavelengths()
W_m = lw[np.array(l2).argmax()]
print("After : ", int(Y), int(Z), "Y =", int(positionvalue(5)),
"Z =", int(positionvalue(6)), "Imax =", int(max(l2)))
print("Longeur d'onde Imax :", W_m)
return max(l2)
cov = matern32()
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ExpectedImprovement')
param = {'Z': ('cont', [0, 120 * 35]), 'Y': ('cont', [0, 120 * 20])}
#np.random.seed(20)
gpgo = GPGO(gp, acq, scan_f, param)
gpgo.run(max_iter=10)
gpgo.getResultZ() #
print("Z max :", gpgo.getResultZ())
gpgo.getResultY()
print("Y Max:", gpgo.getResultY())
print(gpgo.getResult())
mouve(5, gpgo.getResultY(), 'ABSOL')
mouve(6, gpgo.getResultZ(), 'ABSOL')
def scan_S(S, Y, Z):
execution(ser,
'CRES4') # CRESn -> reset current position for an axis
execution(ser, 'CRES5')
execution(ser, 'CRES6')
mouve(4, S, 'RELAT')
mouve(5, Y, 'RELAT')
mouve(6, Z, 'RELAT')
if positionvalue(4) != S:
time.sleep(0.2)
l = spec.intensities()
#
return max(l)
#
cov = matern32()
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ProbabilityImprovement')
param = {
'S': ('cont', [-150, 150]),
'Z': ('cont', [-50, 50]),
'Y': ('cont', [-50, 50])
}
#
np.random.seed(20)
gpgo = GPGO(gp, acq, scan_S, param)
gpgo.run(max_iter=10)
mouve(5, gpgo.getResultY(), 'ABSOL')
mouve(6, gpgo.getResultZ(), 'ABSOL')
mouve(4, gpgo.getResultS(), 'ABSOL')
def hyperparam_search(
self,
params_dict,
train_dataset,
valid_dataset,
output_transformers,
metric,
direction=True,
n_features=1024,
n_tasks=1,
max_iter=20,
search_range=4,
hp_invalid_list=[
'seed', 'nb_epoch', 'penalty_type', 'dropouts', 'bypass_dropouts',
'n_pair_feat', 'fit_transformers', 'min_child_weight',
'max_delta_step', 'subsample', 'colsample_bylevel',
'colsample_bytree', 'reg_alpha', 'reg_lambda', 'scale_pos_weight',
'base_score'
],
log_file='GPhypersearch.log'):
"""Perform hyperparams search using a gaussian process assumption
params_dict include single-valued parameters being optimized,
which should only contain int, float and list of int(float)
parameters with names in hp_invalid_list will not be changed.
For Molnet models, self.model_class is model name in string,
params_dict = dc.molnet.preset_hyper_parameters.hps[self.model_class]
Parameters
----------
params_dict: dict
dict including parameters and their initial values
parameters not suitable for optimization can be added to hp_invalid_list
train_dataset: dc.data.Dataset struct
dataset used for training
valid_dataset: dc.data.Dataset struct
dataset used for validation(optimization on valid scores)
output_transformers: list of dc.trans.Transformer
transformers for evaluation
metric: list of dc.metrics.Metric
metric used for evaluation
direction: bool
maximization(True) or minimization(False)
n_features: int
number of input features
n_tasks: int
number of tasks
max_iter: int
number of optimization trials
search_range: int(float)
optimization on [initial values / search_range,
initial values * search_range]
hp_invalid_list: list
names of parameters that should not be optimized
logfile: string
name of log file, hyperparameters and results for each trial will be recorded
Returns
-------
hyper_parameters: dict
params_dict with all optimized values
valid_performance_opt: float
best performance on valid dataset
"""
assert len(metric) == 1, 'Only use one metric'
hyper_parameters = params_dict
hp_list = list(hyper_parameters.keys())
for hp in hp_invalid_list:
if hp in hp_list:
hp_list.remove(hp)
hp_list_class = [hyper_parameters[hp].__class__ for hp in hp_list]
assert set(hp_list_class) <= set([list, int, float])
# Float or int hyper parameters(ex. batch_size, learning_rate)
hp_list_single = [
hp_list[i] for i in range(len(hp_list)) if not hp_list_class[i] is list
]
# List of float or int hyper parameters(ex. layer_sizes)
hp_list_multiple = [(hp_list[i], len(hyper_parameters[hp_list[i]]))
for i in range(len(hp_list))
if hp_list_class[i] is list]
# Number of parameters
n_param = len(hp_list_single)
if len(hp_list_multiple) > 0:
n_param = n_param + sum([hp[1] for hp in hp_list_multiple])
# Range of optimization
param_range = []
for hp in hp_list_single:
if hyper_parameters[hp].__class__ is int:
param_range.append((('int'), [
hyper_parameters[hp] // search_range,
hyper_parameters[hp] * search_range
]))
else:
param_range.append((('cont'), [
hyper_parameters[hp] / search_range,
hyper_parameters[hp] * search_range
]))
for hp in hp_list_multiple:
if hyper_parameters[hp[0]][0].__class__ is int:
param_range.extend([(('int'), [
hyper_parameters[hp[0]][i] // search_range,
hyper_parameters[hp[0]][i] * search_range
]) for i in range(hp[1])])
else:
param_range.extend([(('cont'), [
hyper_parameters[hp[0]][i] / search_range,
hyper_parameters[hp[0]][i] * search_range
]) for i in range(hp[1])])
# Dummy names
param_name = ['l' + format(i, '02d') for i in range(20)]
param = dict(zip(param_name[:n_param], param_range))
data_dir = os.environ['DEEPCHEM_DATA_DIR']
log_file = os.path.join(data_dir, log_file)
def f(l00=0,
l01=0,
l02=0,
l03=0,
l04=0,
l05=0,
l06=0,
l07=0,
l08=0,
l09=0,
l10=0,
l11=0,
l12=0,
l13=0,
l14=0,
l15=0,
l16=0,
l17=0,
l18=0,
l19=0):
""" Optimizing function
Take in hyper parameter values and return valid set performances
Parameters
----------
l00~l19: int or float
placeholders for hyperparameters being optimized,
hyper_parameters dict is rebuilt based on input values of placeholders
Returns:
--------
valid_scores: float
valid set performances
"""
args = locals()
# Input hyper parameters
i = 0
for hp in hp_list_single:
hyper_parameters[hp] = float(args[param_name[i]])
if param_range[i][0] == 'int':
hyper_parameters[hp] = int(hyper_parameters[hp])
i = i + 1
for hp in hp_list_multiple:
hyper_parameters[hp[0]] = [
float(args[param_name[j]]) for j in range(i, i + hp[1])
]
if param_range[i][0] == 'int':
hyper_parameters[hp[0]] = map(int, hyper_parameters[hp[0]])
i = i + hp[1]
logger.info(hyper_parameters)
# Run benchmark
with open(log_file, 'a') as f:
# Record hyperparameters
f.write(str(hyper_parameters))
f.write('\n')
if isinstance(self.model_class, str) or isinstance(
self.model_class, unicode):
try:
train_scores, valid_scores, _ = benchmark_classification(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=hyper_parameters)
except AssertionError:
train_scores, valid_scores, _ = benchmark_regression(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=hyper_parameters)
score = valid_scores[self.model_class][metric[0].name]
else:
model_dir = tempfile.mkdtemp()
model = self.model_class(hyper_parameters, model_dir)
model.fit(train_dataset, **hyper_parameters)
model.save()
evaluator = Evaluator(model, valid_dataset, output_transformers)
multitask_scores = evaluator.compute_model_performance(metric)
score = multitask_scores[metric[0].name]
with open(log_file, 'a') as f:
# Record performances
f.write(str(score))
f.write('\n')
# GPGO maximize performance by default, set performance to its negative value for minimization
if direction:
return score
else:
return -score
import pyGPGO
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
cov = matern32()
gp = GaussianProcess(cov)
acq = Acquisition(mode='ExpectedImprovement')
gpgo = GPGO(gp, acq, f, param)
logger.info("Max number of iteration: %i" % max_iter)
gpgo.run(max_iter=max_iter)
hp_opt, valid_performance_opt = gpgo.getResult()
# Readout best hyper parameters
i = 0
for hp in hp_list_single:
hyper_parameters[hp] = float(hp_opt[param_name[i]])
if param_range[i][0] == 'int':
hyper_parameters[hp] = int(hyper_parameters[hp])
i = i + 1
for hp in hp_list_multiple:
hyper_parameters[hp[0]] = [
float(hp_opt[param_name[j]]) for j in range(i, i + hp[1])
]
if param_range[i][0] == 'int':
hyper_parameters[hp[0]] = map(int, hyper_parameters[hp[0]])
i = i + hp[1]
# Compare best model to default hyperparameters
with open(log_file, 'a') as f:
# Record hyperparameters
f.write(str(params_dict))
f.write('\n')
if isinstance(self.model_class, str) or isinstance(self.model_class,
unicode):
try:
train_scores, valid_scores, _ = benchmark_classification(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=params_dict)
except AssertionError:
train_scores, valid_scores, _ = benchmark_regression(
train_dataset,
valid_dataset,
valid_dataset, ['task_placeholder'] * n_tasks,
output_transformers,
n_features,
metric,
self.model_class,
hyper_parameters=params_dict)
score = valid_scores[self.model_class][metric[0].name]
with open(log_file, 'a') as f:
# Record performances
f.write(str(score))
f.write('\n')
if not direction:
score = -score
if score > valid_performance_opt:
# Optimized model is better, return hyperparameters
return params_dict, score
# Return default hyperparameters
return hyper_parameters, valid_performance_opt
"""
Plots Franke's function
"""
x = np.linspace(0, 1, num=1000)
y = np.linspace(0, 1, num=1000)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,
linewidth=0)
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
if __name__ == '__main__':
plotFranke()
cov = matern32() # Using a matern v=3/2 covariance kernel
gp = GaussianProcess(cov) # A Gaussian Process regressor without hyperparameter optimization
acq = Acquisition(mode='ExpectedImprovement') # Expected Improvement acquisition function
param = {'x': ('cont', [0, 1]),
'y': ('cont', [0, 1])} # Specify parameter space
np.random.seed(1337)
gpgo = GPGO(gp, acq, f, param) # Call GPGO class
gpgo.run(max_iter=10) # 10 iterations
gpgo.getResult() # Get your result
def zoom_scan():
choice = QtGui.QMessageBox.question(self, 'Precision Scan', "Do you want to get a more accurate point?", # We create a Message box and a choice for the user
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No)
if choice == QtGui.QMessageBox.Yes:
S_ini = (int(execution(ser, '?CNT4'))) # Motor 4
Y_ini = (int(execution(ser, '?CNT5'))) #?CNTn -> Read the position value of axis n
Z_ini = (int(execution(ser, '?CNT6')))
print(S_ini, Y_ini, Z_ini)
from pyGPGO.covfunc import matern32 # pyGPGO allow us to use the Bayesian optimization
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
if c == 1: # Used to convert µm in step and vice versa
range_focus = convert_str_int(self.range_focus.text(), 1) # We let the user choose the focus range
else:
range_focus = convert_str_int(self.range_focus.text(), 20)
intTval = convert_str_int(self.intT.text(),1000)
spec.integration_time_micros(intTval)
def scan_S(S, Y, Z):
mouve(4, S_ini + S, 'ABSOL') #This time it also move on the s axis
mouve(5, Y_ini + Y, 'ABSOL')
mouve(6, Z_ini + Z, 'ABSOL')
while execution(ser, "?ASTAT") != "RRRRRRUUU": #Wait for the end of the movement
time.sleep(0.1)
l = spec.intensities() # Read all intensities of the spectrum for each point
s = slice(1500, 2100)
m = slice(2500, 3500)
threshold = np.std(l[m])
print(mean(l[m]), max(l[s]))
if max(l[s])>3*mean(l[m]): # Work like the other threshold
return max(l[s]) # Return the highest intensity
else:
return max(l[s])/3 # Reduce intensities' value that aren't above the threshold
cov = matern32() # We choose the covariance function
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ExpectedImprovement')
param = {'S': ('cont', [-(3 / 5) * range_focus, (2 / 5) * range_focus]), # We set the range for Y, Z and S
'Z': ('cont', [-diameterZ * 0.1, diameterZ * 0.1]),
'Y': ('cont', [-diameterY * 0.1, diameterY * 0.1])}
N_baye = convert_str_int(self.N_baye.text(), 1) # We let the user choose for the number of iterations of the bayesian process
gpgo = GPGO(gp, acq, scan_S, param)
gpgo.run(max_iter=N_baye) # Launch of the bayesian process
mouve(5, Y_ini + gpgo.getResultY(), 'ABSOL')
mouve(6, Z_ini + gpgo.getResultZ(), 'ABSOL')
mouve(4, S_ini + gpgo.getResultS(), 'ABSOL')
while execution(ser, "?ASTAT") != "RRRRRRUUU":
time.sleep(0.1)
if c == 1:
self.Yscan.setText(str(-1 * round(Y_ini - gpgo.getResultY(), 2))) # Print all the results on the GUI
self.Zscan.setText(str(round(Z_ini - gpgo.getResultZ(), 2)))
self.Imax.setText(str(round(gpgo.getResultI(), 0)))
self.Smax.setText(str(round(S_ini + gpgo.getResultS(), 2)))
else:
self.Yscan.setText(str(-1 * round((Y_ini - gpgo.getResultY()) / 20, 2)))
self.Zscan.setText(str(round((Z_ini - gpgo.getResultZ()) / 40, 2)))
self.Imax.setText(str(round(gpgo.getResultI(), 0)))
self.Smax.setText(str(round((S_ini + gpgo.getResultS()) / 20, 2)))
else:
pass
def Bayesian(self):
from statistics import mean
spec = sb.Spectrometer(devices[0])
intTval = convert_str_int(self.intT.text(), 1000)
spec.integration_time_micros(intTval)
if c == 1:
diameterZ = convert_str_int(self.Di.text(), 2)
diameterY = convert_str_int(self.Di.text(), 1)
else:
diameterZ = convert_str_int(self.Di.text(), 40)
diameterY = convert_str_int(self.Di.text(), 20)
print("Diameter Z and Y :", diameterY, diameterZ)
S_ini = (int(execution(ser, '?CNT4'))) # Motor 4
Y_ini = (int(execution(ser, '?CNT5')))
Z_ini = (int(execution(ser, '?CNT6')))
print(S_ini, Y_ini, Z_ini)
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
if c == 1:
range_focus = convert_str_int(self.range_focus.text(), 1)
else:
range_focus = convert_str_int(self.range_focus.text(), 20)
intTval = convert_str_int(self.intT.text(), 1000)
spec.integration_time_micros(intTval)
def scan_F(S, Y, Z):
mouve(4, S_ini + S, 'ABSOL')
mouve(5, Y_ini + Y, 'ABSOL')
mouve(6, Z_ini + Z, 'ABSOL')
while execution(ser, "?ASTAT") != "RRRRRRUUU":
time.sleep(0.1)
l = spec.intensities()
s = slice(1500, 2100)
m = slice(2500, 3500)
threshold = np.std(l[m])
if max(l[s]) > 3 * threshold:
return max(l[s])
else:
return None
cov = matern32()
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ExpectedImprovement')
param = {'S': ('cont', [-(4 / 5) * range_focus, (4 / 5) * range_focus]),
'Z': ('cont', [-diameterZ/2, diameterZ/2]),
'Y': ('cont', [-diameterY/2, diameterY/2])}
N_baye = convert_str_int(self.N_baye.text(), 1)
gpgo = GPGO(gp, acq, scan_F, param)
gpgo.run(max_iter=N_baye)
mouve(5, Y_ini + gpgo.getResultY(), 'ABSOL')
mouve(6, Z_ini + gpgo.getResultZ(), 'ABSOL')
mouve(4, S_ini + gpgo.getResultS(), 'ABSOL')
while execution(ser, "?ASTAT") != "RRRRRRUUU":
time.sleep(0.1)
if c == 1:
self.Yscan.setText(str(-1 * round(Y_ini - gpgo.getResultY(), 2)))
self.Zscan.setText(str(round(Z_ini - gpgo.getResultZ(), 2)))
self.Imax.setText(str(round(gpgo.getResultI(), 0)))
self.Smax.setText(str(round(S_ini + gpgo.getResultS(), 2)))
else:
self.Yscan.setText(str(-1 * round((Y_ini - gpgo.getResultY()) / 20, 2)))
self.Zscan.setText(str(round((Z_ini - gpgo.getResultZ()) / 40, 2)))
self.Imax.setText(str(round(gpgo.getResultI(), 0)))
self.Smax.setText(str(round((S_ini + gpgo.getResultS()) / 20, 2)))
spec.close()
devices = []
def hyperparam_search(
self,
params_dict,
train_dataset,
valid_dataset,
output_transformers,
metric,
prot_desc_dict,
prot_desc_length,
tasks=None,
direction=True,
n_features=1024,
n_tasks=1,
max_iter=20,
search_range=4,
early_stopping=True,
evaluate_freq=3,
patience=3,
model_dir="./model_dir",
hp_invalid_list=[
'seed', 'nb_epoch', 'penalty_type', 'dropouts',
'bypass_dropouts', 'n_pair_feat', 'fit_transformers',
'min_child_weight', 'weight_init_stddevs', 'max_delta_step',
'subsample', 'colsample_bylevel', 'bias_init_consts',
'colsample_bytree', 'reg_alpha', 'reg_lambda',
'scale_pos_weight', 'base_score', 'layer_sizes'
],
log_file='GPhypersearch.log',
mode='classification',
tensorboard=True,
no_concordance_index=False,
no_r2=False,
plot=False,
verbose_search=False,
aggregated_tasks=[]):
"""Perform hyperparams search using a gaussian process assumption
params_dict include single-valued parameters being optimized,
which should only contain int, float and list of int(float)
parameters with names in hp_invalid_list will not be changed.
For Molnet models, self.model_class is model name in string,
params_dict = dc.molnet.preset_hyper_parameters.hps[self.model_class]
Parameters
----------
params_dict: dict
dict including parameters and their initial values
parameters not suitable for optimization can be added to hp_invalid_list
train_dataset: dc.data.Dataset struct
dataset used for training
valid_dataset: dc.data.Dataset struct
dataset used for validation(optimization on valid scores)
output_transformers: list of dc.trans.Transformer
transformers for evaluation
metric: list of dc.metrics.Metric
metric used for evaluation
direction: bool
maximization(True) or minimization(False)
n_features: int
number of input features
n_tasks: int
number of tasks
max_iter: int
number of optimization trials
search_range: int(float)
optimization on [initial values / search_range,
initial values * search_range]
hp_invalid_list: list
names of parameters that should not be optimized
logfile: string
name of log file, hyperparameters and results for each trial will be recorded
Returns
-------
hyper_parameters: dict
params_dict with all optimized values
valid_performance_opt: float
best performance on valid dataset
"""
#assert len(metric) == 1, 'Only use one metric'
hyper_parameters = params_dict
hp_list = list(hyper_parameters.keys())
for hp in hp_invalid_list:
if hp in hp_list:
hp_list.remove(hp)
hp_list_class = [hyper_parameters[hp].__class__ for hp in hp_list]
assert set(hp_list_class) <= set([list, int, float])
# Float or int hyper parameters(ex. batch_size, learning_rate)
hp_list_single = [
hp_list[i] for i in range(len(hp_list))
if not hp_list_class[i] is list
]
# List of float or int hyper parameters(ex. layer_sizes)
hp_list_multiple = [(hp_list[i], len(hyper_parameters[hp_list[i]]))
for i in range(len(hp_list))
if hp_list_class[i] is list]
# Number of parameters
n_param = len(hp_list_single)
if len(hp_list_multiple) > 0:
n_param = n_param + sum([hp[1] for hp in hp_list_multiple])
# Range of optimization
param_range = []
for hp in hp_list_single:
if hyper_parameters[hp].__class__ is int:
param_range.append((('int'), [
hyper_parameters[hp] // search_range,
hyper_parameters[hp] * search_range
]))
else:
param_range.append((('cont'), [
hyper_parameters[hp] / search_range,
hyper_parameters[hp] * search_range
]))
for hp in hp_list_multiple:
if hyper_parameters[hp[0]][0].__class__ is int:
param_range.extend([(('int'), [
hyper_parameters[hp[0]][i] // search_range,
hyper_parameters[hp[0]][i] * search_range
]) for i in range(hp[1])])
else:
param_range.extend([(('cont'), [
hyper_parameters[hp[0]][i] / search_range,
hyper_parameters[hp[0]][i] * search_range
]) for i in range(hp[1])])
# Dummy names
param_name = ['l' + format(i, '02d') for i in range(20)]
param = dict(zip(param_name[:n_param], param_range))
data_dir = './logs'
log_file = os.path.join(data_dir, log_file)
def f(l00=0,
l01=0,
l02=0,
l03=0,
l04=0,
l05=0,
l06=0,
l07=0,
l08=0,
l09=0,
l10=0,
l11=0,
l12=0,
l13=0,
l14=0,
l15=0,
l16=0,
l17=0,
l18=0,
l19=0):
""" Optimizing function
Take in hyper parameter values and return valid set performances
Parameters
----------
l00~l19: int or float
placeholders for hyperparameters being optimized,
hyper_parameters dict is rebuilt based on input values of placeholders
Returns:
--------
valid_scores: float
valid set performances
"""
args = locals()
# Input hyper parameters
i = 0
for hp in hp_list_single:
hyper_parameters[hp] = float(args[param_name[i]])
if param_range[i][0] == 'int':
hyper_parameters[hp] = int(hyper_parameters[hp])
i = i + 1
for hp in hp_list_multiple:
hyper_parameters[hp[0]] = [
float(args[param_name[j]]) for j in range(i, i + hp[1])
]
if param_range[i][0] == 'int':
hyper_parameters[hp[0]] = list(
map(int, hyper_parameters[hp[0]]))
i = i + hp[1]
opt_epoch = -1
print(hyper_parameters)
nonlocal model_dir
pdb.set_trace()
# Run benchmark
with open(log_file, 'a') as f:
# Record hyperparameters
f.write(str(hyper_parameters))
f.write('\n')
if isinstance(self.model_class, str) or isinstance(
self.model_class, unicode):
if mode == 'classification':
train_scores, valid_scores, _, opt_epoch = model_classification(
train_dataset,
valid_dataset,
valid_dataset,
tasks,
output_transformers,
n_features,
metric,
self.model_class,
prot_desc_dict,
prot_desc_length,
hyper_parameters=hyper_parameters,
early_stopping=early_stopping,
evaluate_freq=evaluate_freq,
patience=patience,
direction=direction,
model_dir=model_dir,
tensorboard=tensorboard,
no_concordance_index=no_concordance_index,
verbose_search=verbose_search,
log_file=log_file,
no_r2=no_r2,
aggregated_tasks=aggregated_tasks)
elif mode == 'regression' or mode == 'reg-threshold':
train_scores, valid_scores, _, opt_epoch = model_regression(
train_dataset,
valid_dataset,
valid_dataset,
tasks,
output_transformers,
n_features,
metric,
self.model_class,
prot_desc_dict,
prot_desc_length,
hyper_parameters=hyper_parameters,
early_stopping=early_stopping,
evaluate_freq=evaluate_freq,
patience=patience,
direction=direction,
model_dir=model_dir,
tensorboard=tensorboard,
no_concordance_index=no_concordance_index,
verbose_search=verbose_search,
log_file=log_file,
no_r2=no_r2,
aggregated_tasks=aggregated_tasks)
else:
raise ValueError("Invalid mode!")
# similar to fit() function in tensor_graph.py, we also use combination here.
if n_tasks > 1:
val_scores = valid_scores[self.model_class]['averaged']
else:
val_scores = valid_scores[self.model_class]
score = 0
if mode == 'regression':
for mtc in metric:
mtc_name = mtc.metric.__name__
composite_mtc_name = mtc.name
if mtc_name == 'rms_score':
score += val_scores[composite_mtc_name]
if mtc_name == 'r2_score' or mtc_name == 'pearson_r2_score':
if no_r2:
coef = 0.0
else:
coef = -0.5
score += coef * val_scores[composite_mtc_name]
if mtc_name == 'concordance_index':
score += -val_scores[composite_mtc_name]
elif mode == 'reg-threshold' or mode == 'classification':
for mtc in metric:
mtc_name = mtc.metric.__name__
composite_mtc_name = mtc.name
if mtc_name == 'roc_auc_score':
score += val_scores[composite_mtc_name]
if mtc_name == 'prc_auc_score':
score += val_scores[composite_mtc_name]
else:
model_dir = tempfile.mkdtemp()
model = self.model_class(hyper_parameters, model_dir)
model.fit(train_dataset, **hyper_parameters)
model.save()
evaluator = Evaluator(model, valid_dataset,
output_transformers)
multitask_scores = evaluator.compute_model_performance(
[metric])
score = multitask_scores[metric.name]
#pdb.set_trace()
if early_stopping:
best_score = opt_epoch[1]
opt_epoch = opt_epoch[0]
epoch_stmt = str(
opt_epoch) + " is the optimum number of epochs found."
print(epoch_stmt)
with open(log_file, 'a') as f:
# Record performances
f.write(self.model_class)
f.write('\n')
f.write(epoch_stmt)
f.write('\n')
f.write(str(score))
f.write('\n')
if early_stopping:
f.write(str(best_score))
f.write('\n')
if not early_stopping:
best_score = score
# GPGO maximize performance by default, set performance to its negative value for minimization
if direction:
return best_score
else:
return -best_score
import pyGPGO
from pyGPGO.covfunc import matern32
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
with open(log_file, 'a') as file:
file.write(
"------------------------------------------------------------------"
)
file.write('\n')
cov = matern32()
gp = GaussianProcess(cov)
acq = Acquisition(mode='ExpectedImprovement')
gpgo = GPGO(gp, acq, f, param)
print("Max number of iteration: %i" % max_iter)
gpgo.run(max_iter=max_iter)
hp_opt, valid_performance_opt = gpgo.getResult()
# Readout best hyper parameters
i = 0
for hp in hp_list_single:
hyper_parameters[hp] = float(hp_opt[param_name[i]])
if param_range[i][0] == 'int':
hyper_parameters[hp] = int(hyper_parameters[hp])
i = i + 1
for hp in hp_list_multiple:
hyper_parameters[hp[0]] = [
float(hp_opt[param_name[j]]) for j in range(i, i + hp[1])
]
if param_range[i][0] == 'int':
hyper_parameters[hp[0]] = list(
map(int, hyper_parameters[hp[0]]))
i = i + hp[1]
opt_epoch = -1
# Compare best model to default hyperparameters
with open(log_file, 'a') as f:
# Record hyperparameters
f.write(str(params_dict))
f.write('\n')
if isinstance(self.model_class, str) or isinstance(
self.model_class, unicode):
if mode == 'classification':
train_scores, valid_scores, _, opt_epoch = model_classification(
train_dataset,
valid_dataset,
valid_dataset,
tasks,
output_transformers,
n_features,
metric,
self.model_class,
prot_desc_dict,
prot_desc_length,
hyper_parameters=params_dict,
early_stopping=early_stopping,
evaluate_freq=evaluate_freq,
patience=patience,
direction=direction,
model_dir=model_dir,
tensorboard=tensorboard,
no_concordance_index=no_concordance_index,
verbose_search=verbose_search,
log_file=log_file,
no_r2=no_r2,
aggregated_tasks=aggregated_tasks)
elif mode == 'regression' or mode == 'reg-threshold':
train_scores, valid_scores, _, opt_epoch = model_regression(
train_dataset,
valid_dataset,
valid_dataset,
tasks,
output_transformers,
n_features,
metric,
self.model_class,
prot_desc_dict,
prot_desc_length,
hyper_parameters=params_dict,
early_stopping=early_stopping,
evaluate_freq=evaluate_freq,
patience=patience,
direction=direction,
model_dir=model_dir,
tensorboard=tensorboard,
no_concordance_index=no_concordance_index,
verbose_search=verbose_search,
log_file=log_file,
no_r2=no_r2,
aggregated_tasks=aggregated_tasks)
else:
raise ValueError("Invalid mode!")
if n_tasks > 1:
val_scores = valid_scores[self.model_class]['averaged']
else:
val_scores = valid_scores[self.model_class]
score = 0
if mode == 'regression':
for mtc in metric:
mtc_name = mtc.metric.__name__
composite_mtc_name = mtc.name
if mtc_name == 'rms_score':
score += val_scores[composite_mtc_name]
if mtc_name == 'r2_score' or mtc_name == 'pearson_r2_score':
if no_r2:
coef = 0.0
else:
coef = -0.5
score += coef * val_scores[composite_mtc_name]
if mtc_name == 'concordance_index':
score += -val_scores[composite_mtc_name]
elif mode == 'reg-threshold' or mode == 'classification':
for mtc in metric:
mtc_name = mtc.metric.__name__
composite_mtc_name = mtc.name
if mtc_name == 'roc_auc_score':
score += val_scores[composite_mtc_name]
if mtc_name == 'prc_auc_score':
score += val_scores[composite_mtc_name]
if early_stopping:
best_score = opt_epoch[1]
opt_epoch = opt_epoch[0]
epoch_stmt = str(
opt_epoch) + " is the optimum number of epochs found."
print(epoch_stmt)
#pdb.set_trace()
with open(log_file, 'a') as f:
f.write(epoch_stmt)
f.write('\n')
# Record performances
f.write(str(score))
f.write('\n')
if early_stopping:
f.write(str(best_score))
f.write('\n')
if not early_stopping:
best_score = score
# I have changed the determination criteria from score to best_score.
if not direction:
best_score = -best_score
if best_score > valid_performance_opt:
# Default model is better, return hyperparameters
return params_dict, best_score
# Return optimized hyperparameters
return hyper_parameters, valid_performance_opt
def Scan(self):
from pyGPGO.covfunc import matern32 # pyGPGO est le module qui permet d'éffectuer l'optimisation bayèsienne
from pyGPGO.acquisition import Acquisition
from pyGPGO.surrogates.GaussianProcess import GaussianProcess
from pyGPGO.GPGO import GPGO
diameterZ = convert_str_int(
self.Di.text(), 35
) # On définit le diamètre en fonction de l'indication de l'utilisateur, 35 est le facteur de conversion de Z
diameterY = convert_str_int(
self.Di.text(), 20
) # La fonction convert_str_int() convertit une chaîne de caractère et la multiplie par le 2ième argument
range_focus = convert_str_int(
self.focus.text(), 0.5
) # On divise cette valeur par 2 car l'intervalle va être [-range_focus;range_focus]
spec.integration_time_micros(
100 * 1000
) #On définit le temps d'intégration sans laisser le choix à l'utilisateur
def scan_f(Z, Y):
l1 = spec.intensities()
#print("\n")
#print("Before :", int(Y), int(Z), int(positionvalue(5)), int(positionvalue(6)), int(max(l1)))
#mouve(4, S, 'ABSOL')
mouve(5, Y, 'ABSOL')
mouve(6, Z, 'ABSOL')
#print(execution(ser, "?ASTAT"))
#time.sleep(0.2)
#print(execution(ser, "?ASTAT"))
#time.sleep(1.2)#
#print(execution(ser, "?ASTAT"))
##
while execution(ser, "?ASTAT") != "RRRRRRUUU":
time.sleep(0.1)
l2 = spec.intensities()
lw = spec.wavelengths()
W_m = lw[np.array(l2).argmax()]
#print("After : ", int(Y), int(Z), "Y =",int(positionvalue(5)),"Z =", int(positionvalue(6)),"Imax =", int(max(l2)))
#print("Longeur d'onde Imax :",W_m)
#
return max(l2)
cov = matern32()
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ExpectedImprovement')
param = {
'Z': ('cont', [0,
diameterZ]), # On définit les intervalles de Z et Y
'Y': ('cont', [0, diameterY])
}
#np.random.seed(20)
gpgo = GPGO(gp, acq, scan_f, param)
gpgo.run(
max_iter=10
) # On lance l'optimisation e nindiquant le nombre d'itérations à réaliser
gpgo.getResultZ()
print("Z max :", gpgo.getResultZ())
gpgo.getResultY()
print("Y Max:", gpgo.getResultY())
print(gpgo.getResult())
mouve(5, gpgo.getResultY(),
'ABSOL') # On déplace la cellule aux coordonnées du rubis
mouve(6, gpgo.getResultZ(), 'ABSOL')
execution(
ser, 'CRES4'
) # CRESn -> reset current position for an axis # On réinitialise l'origine de tout les points
execution(
ser, 'CRES5'
) # Cela est toujours nécéssaires pour se replacer sur les coordonnées
execution(ser, 'CRES6') # du rubis après la nouvelle optimisation
def scan_S(S, Y, Z):
mouve(
4, S, 'RELAT'
) # Cette fois on se déplace aussi en profondeur, sur l'axe S
mouve(5, Y, 'RELAT')
mouve(6, Z, 'RELAT')
while execution(
ser, "?ASTAT"
) != "RRRRRRUUU": # On attend la fin du déplacement
time.sleep(0.1)
l = spec.intensities() #On relève le spèctre
#
return max(
l) # On renvoie le maximun d'intensité su spectre obtenu
#
cov = matern32()
gp = GaussianProcess(cov, optimize=True, usegrads=True)
acq = Acquisition(mode='ProbabilityImprovement')
param = {
'S':
('cont', [-range_focus, range_focus
]), # On définit les intervalles de valeurs de S,Y et Z
'Z': ('cont', [-50, 50]),
'Y': ('cont', [-50, 50])
}
#
#np.random.seed(20)
gpgo = GPGO(gp, acq, scan_S, param)
gpgo.run(max_iter=10
) # On lance l'lgorithme qui doit éffectuer 10 itérations
mouve(5, gpgo.getResultY(), 'ABSOL')
mouve(6, gpgo.getResultZ(), 'ABSOL')
mouve(4, gpgo.getResultS(), 'ABSOL')
end = time.time() # Permet de mesurer le temps d'optimisation
print(end - start)
self.Yscan.setText(str(round(
-1 * gpgo.getResultY(),
2))) # On affiche tous les résultats sur l'interface graphique
self.Zscan.setText(str(round(gpgo.getResultZ(), 2)))
self.Imax.setText(str(round(gpgo.getResultI(), 0)))
self.Smax.setText(str(round(gpgo.getResultS(), 2)))
surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0)
fig.colorbar(surf, shrink=0.5, aspect=5)
best = gpgo.best
ax.scatter([best[0]], [best[1]],
s=40,
marker='x',
c='r',
label='Sampled point')
plt.legend(bbox_to_anchor=(1.3, 0.05))
ax.set_xlabel('dropout')
ax.set_ylabel('learning rate')
#plt.show()
return Z
cov = matern32(
) # other kernel types: sqdExp, matern, matern52, gammaExp, rationalQuadratic
gp = GaussianProcess(cov)
acq = Acquisition(mode='ExpectedImprovement'
) # other modes: UCB, ProbabilityImprovement, loads more
param = {'dropout': ('cont', [0, 1]), 'learning_rate': ('cont', [0.1, 1])}
np.random.seed(1337)
gpgo = GPGO(gp, acq, test_model, param)
gpgo.run(max_iter=1)
gpgo.run(max_iter=1, resume=True)
gpgo.history
dir(gpgo)
