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)