# pylint: disable=import-error # pylint: disable=no-member # pylint: disable=invalid-name # pylint: disable=relative-import # pylint: disable=abstract-class-not-used # pylint: disable=super-on-old-class import numpy as np # Local imports import gp_core import kernel from utils.option_handler import get_option_specs # Some basic parameters for simple GPs. basic_gp_args = [ get_option_specs('kernel_type', False, 'se', 'Specify type of kernel. Should be se or poly'), get_option_specs( 'mean_func_type', False, 'median', ('Specify the type of mean function. Should be mean, median, const ', 'or zero. If const, specifcy value in mean-func-const.')), get_option_specs('mean_func_const', False, 0.0, 'The constant value to use if mean_func_type is const.'), get_option_specs( 'noise_var_type', False, 'tune', ('Specify how to obtain the noise variance. Should be tune, label ', 'or value. Specify appropriate value in noise_var_label or', 'noise_var_value')), get_option_specs( 'noise_var_label', False, 0.05, 'The fraction of label variance to use as noise variance.'), get_option_specs('noise_var_value', False, 0.1,
from chemist_opt.blackbox_optimiser import blackbox_opt_args from mols.mol_gp import mol_gp_args, MolGPFitter from mols.mol_kernels import * # kernel names from datasets.loaders import get_initial_pool from chemist_opt.gp_bandit import GPBandit, gp_bandit_args from utils.general_utils import block_augment_array from utils.reporters import get_reporter from utils.option_handler import get_option_specs, load_options # Options for acquisition optimizers: # - random_ga: randomly select subsets and synthesize # - ToBeAdded chemist_specific_args = [ get_option_specs( 'chemist_acq_opt_method', False, 'ga', 'Which method to use when optimising the acquisition. Will override acq_opt_method' + ' in the arguments for gp_bandit.'), ] all_chemist_args = chemist_specific_args + gp_bandit_args + \ blackbox_opt_args + mol_gp_args class Chemist(GPBandit): """ Analog of NASBOT class. To not have it inherit from any GPBandit, must merge and simplify all functionality. """ def __init__(self,
_DFLT_RECTIFIER_SWAP = MLP_RECTIFIERS _PRIMITIVE_PROB_MASSES = {'inc_single': 0.1, 'dec_single': 0.1, 'inc_en_masse': 0.1, 'dec_en_masse': 0.1, 'swap_layer': 0.2, 'wedge_layer': 0.1, 'remove_layer': 0.1, 'branch': 0.2, 'skip': 0.2, } nn_modifier_args = [ # Change fractions for increasing the number of units in layers. get_option_specs('single_inc_change_frac', False, _DFLT_CHANGE_FRAC, 'Default change fraction when increasing a single layer.'), get_option_specs('single_dec_change_frac', False, _DFLT_CHANGE_FRAC, 'Default change fraction when decreasing a single layer.'), get_option_specs('en_masse_inc_change_frac', False, _DFLT_CHANGE_FRAC, 'Default change fraction when increasing layers en_masse.'), get_option_specs('en_masse_dec_change_frac', False, _DFLT_CHANGE_FRAC, 'Default change fraction when decreasing layers en_masse.'), # Number of networks to spawn by changing number of units in a single layer. get_option_specs('spawn_single_inc_num_units', False, _DFLT_CHANGE_NUM_UNITS_SPAWN, 'Default number of networks to spawn by increasing # units in a single layer.'), get_option_specs('spawn_single_dec_num_units', False, _DFLT_CHANGE_NUM_UNITS_SPAWN, 'Default number of networks to spawn by decreasing # units in a single layer.'), # Number of networks to spawn by adding or deleting a single layer. get_option_specs('spawn_add_layer', False, _DFLT_CHANGE_LAYERS_SPAWN, 'Default number of networks to spawn by adding a layer.'), get_option_specs('spawn_del_layer', False, _DFLT_CHANGE_LAYERS_SPAWN,
[email protected] """ # pylint: disable=invalid-name # pylint: disable=no-member # pylint: disable=abstract-method from numpy.random import choice # Local imports from opt.blackbox_optimiser import BlackboxOptimiser, blackbox_opt_args from utils.general_utils import sample_according_to_exp_probs from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter ga_specific_opt_args = [ get_option_specs('num_mutations_per_epoch', False, 50, 'Number of mutations per epoch.'), get_option_specs('num_candidates_to_mutate_from', False, -1, 'The number of candidates to choose the mutations from.'), get_option_specs( 'fitness_sampler_scaling_const', False, 2, 'The scaling constant for sampling according to exp_probs.'), ] ga_opt_args = ga_specific_opt_args + blackbox_opt_args class GAOptimiser(BlackboxOptimiser): """ Class for optimisation based on Genetic algorithms. """ def __init__(self, func_caller, worker_manager,
# Local from opt.gp_bandit import get_all_gp_bandit_args_from_gp_args from gp.euclidean_gp import euclidean_gp_args from utils.option_handler import get_option_specs, load_options from parse.config_parser import config_parser from utils.reporters import get_reporter from exd.worker_manager import SyntheticWorkerManager from exd.experiment_caller import EuclideanFunctionCaller, FunctionCaller from opt.gp_bandit import EuclideanGPBandit from exd import domains dragonfly_args = [ \ get_option_specs('config', False, None, 'Path to the json or pb config file. '), get_option_specs('options', False, None, 'Path to the options file. '), get_option_specs('max_capital', False, 0.0, 'Maximum capital to be used in the experiment. '), get_option_specs('budget', False, 0.0, \ 'The budget of evaluations. If max_capital is none, will use this as max_capital.'), ] def maximise_function(func, max_capital, domain=None, domain_bounds=None, config=None, options=None, hp_tune_criterion='post_sampling', hp_tune_method='slice', init_capital=None, init_capital_frac=None,
import sys import numpy as np from scipy.linalg import solve_triangular # Local imports from utils.general_utils import stable_cholesky, draw_gaussian_samples, \ project_symmetric_to_psd_cone from utils.oper_utils import direct_ft_maximise, random_maximise, random_sample from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter # These are mandatory requirements. Every GP implementation should probably use them. mandatory_gp_args = [ get_option_specs('hp_tune_criterion', False, 'ml', 'Which criterion to use when tuning hyper-parameters. Other ' + 'options are post_sampling and post_mean.'), get_option_specs('ml_hp_tune_opt', False, 'direct', 'Which optimiser to use when maximising the tuning criterion.'), get_option_specs('hp_tune_max_evals', False, -1, 'How many evaluations to use when maximising the tuning criterion.'), get_option_specs('handle_non_psd_kernels', False, '', 'How to handle kernels that are non-psd.') ] def _solve_lower_triangular(A, b): """ Solves Ax=b when A is lower triangular. """ return solve_triangular(A, b, lower=True) def _solve_upper_triangular(A, b): """ Solves Ax=b when A is upper triangular. """
# pylint: disable=invalid-name # pylint: disable=relative-import import sys import numpy as np from utils.general_utils import stable_cholesky, draw_gaussian_samples from utils.optimisers import direct_ft_maximise from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter # These are mandatory requirements. Every GP implementation should probably use them. mandatory_gp_args = [ get_option_specs('hp_tune_criterion', False, 'ml', 'Which criterion to use when tuning hyper-parameters.'), get_option_specs('hp_tune_opt', False, 'direct', 'Which optimiser to use when maximising the tuning criterion.'), get_option_specs('hp_tune_max_evals', False, -1, 'How many evaluations to use when maximising the tuning criterion.'), ] def _check_feature_label_lengths_and_format(X, Y): """ Checks if the length of X and Y are the same. """ if X.shape[0] != len(Y): raise ValueError('Size of X (' + str(X.shape) + ') and Y (' + str(Y.shape) + ') do not match.') if len(X.shape) != 2 or len(Y.shape) != 1: raise ValueError('X should be an nxd matrix and Y should be an n-vector.' + 'Given shapes of X, Y are: ', str(X.shape) + ', ' + str(Y.shape))
# Local imports from gp import gp_core, mf_gp import gp.kernel as gp_kernel from utils.ancillary_utils import get_list_of_floats_as_str from utils.general_utils import get_sublist_from_indices, map_to_bounds from utils.option_handler import get_option_specs, load_options from utils.oper_utils import random_sample_from_discrete_domain from utils.reporters import get_reporter _DFLT_KERNEL_TYPE = 'se' # Some basic parameters for Euclidean GPs. basic_euc_gp_args = [ \ get_option_specs('kernel_type', False, 'default', 'Specify type of kernel. This depends on the application.'), get_option_specs('use_same_bandwidth', False, False, ('If true, will use same bandwidth on all dimensions. Applies only ' 'when kernel_type is se or matern. Default=False.')), \ ] # Parameters for the SE kernel. se_gp_args = [ \ ] # Parameters for the matern kernel matern_gp_args = [ \ get_option_specs('matern_nu', False, -1.0, \ ('Specify the nu value for the matern kernel. If negative, will fit.')), ] # Parameters for the Polynomial kernel. poly_gp_args = [ \ get_option_specs('use_same_scalings', False, False, 'If true uses same scalings on all dimensions. Default is False.'),
gp_bandit_args = [ \ get_option_specs('acq', False, 'ei-ucb-ttei', \ 'Which acquisition to use: ts, ucb, ei, ttei, bucb. If using multiple ' + \ 'give them as a hyphen separated list e.g. ucb-ts-ei-ttei'), get_option_specs('acq_probs', False, 'adaptive', \ 'With what probability should we choose each strategy given in acq. If "uniform" ' + \ 'we we will use uniform probabilities and if "adaptive" we will use adaptive ' + \ 'probabilities which weight acquisitions according to how well they do.'), get_option_specs('acq_opt_method', False, 'direct', \ 'Which optimiser to use when maximising the acquisition function.'), get_option_specs('handle_parallel', False, 'halluc', \ 'How to handle parallelisations. Should be halluc or naive.'), get_option_specs('acq_opt_max_evals', False, -1, \ 'Number of evaluations when maximising acquisition. If negative uses default value.'), # The following are for managing GP hyper-parameters. They override hp_tune_criterion # and ml_hp_tune_opt from the GP args. get_option_specs('gpb_hp_tune_criterion', False, 'ml-post_sampling', 'Which criterion to use when tuning hyper-parameters. Other ' + 'options are post_sampling and post_mean.'), get_option_specs('gpb_hp_tune_probs', False, '0.3-0.7', \ 'With what probability should we choose each strategy given in hp_tune_criterion.' + \ 'If "uniform" we we will use uniform probabilities and if "adaptive" we will use ' + \ 'adaptive probabilities which weight acquisitions according to how well they do.'), get_option_specs('gpb_ml_hp_tune_opt', False, 'direct', 'Which optimiser to use when maximising the tuning criterion.'), get_option_specs('gpb_post_hp_tune_method', False, 'slice', 'Which sampling to use when maximising the tuning criterion. Other ' + 'option is nuts'), get_option_specs('gpb_post_hp_tune_burn', False, -1, 'How many initial samples to ignore during sampling.'), get_option_specs('gpb_post_hp_tune_offset', False, 25, 'How many samples to ignore between samples.'), get_option_specs('rand_exp_sampling_replace', False, False, \ 'Whether to replace already sampled values or not in rand_exp_sampling.'), # For multi-fidelity BO get_option_specs('mf_strategy', False, 'boca', 'Which multi-fidelity strategy to use. Should be one of {boca}.'), # The following are perhaps not so important. Some have not been implemented yet. get_option_specs('shrink_kernel_with_time', False, 0, 'If True, shrinks the kernel with time so that we don\'t get stuck.'), get_option_specs('perturb_thresh', False, 1e-4, \ ('If the next point chosen is too close to an exisiting point by this times the ' \ 'diameter, then we will perturb the point a little bit before querying. This is ' \ 'mainly to avoid numerical stability issues.')), get_option_specs('track_every_time_step', False, 0, ('If 1, it tracks every time step.')), get_option_specs('next_pt_std_thresh', False, 0.005, \ ('If the std of the queried point queries below this times the kernel scale ', \ 'frequently we will reduce the bandwidth range')), \ ]
# pylint: disable=super-on-old-class import numpy as np # Local imports from gp.kernel import CoordinateProductKernel, PolyKernel, SEKernel from gp.gp_core import GP, GPFitter, mandatory_gp_args from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter from utils.ancillary_utils import get_list_of_floats_as_str # Define hyper-parameters for Multi-fidelity GPs. mf_gp_args = [ # Fidelity kernel get_option_specs('fidel_kernel_type', False, 'se', 'Type of kernel for the fidelity space. Should be se or poly'), get_option_specs('fidel_use_same_bandwidth', False, False, ('If true, will use same bandwidth on all fidelity dimensions. Applies only when ' 'fidel_kernel_type is se. Default=False.')), get_option_specs('fidel_use_same_scalings', False, False, ('If true, will use same scaling on all fidelity dimensions. Applies only when ' 'fidel_kernel_type is poly. Default=False.')), get_option_specs('fidel_poly_order', False, 1, ('Order of the polynomial for the fidelity kernel. Default = 1 (linear kernel)')), # Domain kernel get_option_specs('domain_kernel_type', False, 'se', 'Type of kernel for the domain. Should be se or poly'), get_option_specs('domain_use_same_bandwidth', False, False, ('If true, will use same bandwidth on all domain dimensions. Applies only when ' 'domain_kernel_type is se. Default=False.')), get_option_specs('domain_use_same_scalings', False, False,
# pylint: disable=relative-import # pylint: disable=super-on-old-class # pylint: disable=abstract-class-little-used from argparse import Namespace import time import numpy as np # Local imports import gpb_utils from utils.general_utils import map_to_bounds from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter blackbox_opt_args = [ get_option_specs('max_num_steps', False, 1e7, 'If exceeds this many evaluations, stop.'), get_option_specs('capital_type', False, 'return_value', 'Should be one of return_value, cputime, or realtime'), get_option_specs( 'init_method', False, 'randomkmeans', 'How to initialise. Should be either random, random_kmeans, or latin.' ), get_option_specs('num_init_evals', False, 0, ( 'The amount of evaluations for initialisation. If <0, will use default.' )), get_option_specs('num_workers', False, 1, 'The number of workers in parallel.'), get_option_specs( 'mode', False, 'asy', 'If \'syn\', uses synchronous parallelisation, else asynchronous.'), get_option_specs(
import numpy as np # Local imports from bo import acquisitions from blackbox_optimiser import blackbox_opt_args, BlackboxOptimiser from gp.kernel import SEKernel from gp.gp_core import GP, mandatory_gp_args from gp.gp_instances import SimpleGPFitter, all_simple_gp_args from utils.optimisers import random_maximise from utils.option_handler import get_option_specs, load_options from utils.function_caller import get_function_caller_from_function from utils.reporters import get_reporter gp_bandit_args = [ # Acquisition get_option_specs('acq', False, None, 'Which acquisition to use: TS, UCB, BUCB, UCBPE.'), get_option_specs( 'acq_opt_criterion', False, 'rand', 'Which optimiser to use when maximising the acquisition function.'), get_option_specs( 'acq_opt_max_evals', False, -1, 'Number of evaluations when maximising acquisition. If negative uses default value.' ), # The following are perhaps not so important. get_option_specs( 'shrink_kernel_with_time', False, 0, 'If True, shrinks the kernel with time so that we don\'t get stuck.'), get_option_specs('perturb_thresh', False, 1e-4, ( 'If the next point chosen is too close to an exisiting point by this times the ' 'diameter, then we will perturb the point a little bit before querying. This is ' 'mainly to avoid numerical stability issues.')),
from utils.reporters import get_reporter exd_core_args = [ \ get_option_specs('max_num_steps', False, 1e7, 'If exceeds this many evaluations, stop.'), get_option_specs('capital_type', False, 'return_value', 'Should be one of return_value, cputime, or realtime'), get_option_specs('mode', False, 'asy', \ 'If \'syn\', uses synchronous parallelisation, else asynchronous.'), get_option_specs('build_new_model_every', False, 17, \ 'Updates the model via a suitable procedure every this many iterations.'), get_option_specs('report_results_every', False, 13, 'Report results every this many iterations.'), # Initialisation get_option_specs('init_capital', False, None, ('The capital to be used for initialisation.')), get_option_specs('init_capital_frac', False, None, ('The fraction of the total capital to be used for initialisation.')), get_option_specs('num_init_evals', False, 20, \ ('The number of evaluations for initialisation. If <0, will use default.')), # The amount of effort we will use for initialisation is prioritised by init_capital, # init_capital_frac and num_init_evals. get_option_specs('prev_evaluations', False, None, 'Data for any previous evaluations.'), get_option_specs('get_initial_qinfos', False, None, 'A function to obtain initial qinfos.'), get_option_specs('init_method', False, 'rand', \ 'Method to obtain initial queries. Is used if get_initial_qinfos is None.'), \ ] mf_exd_args = [ \
mandatory_gp_args = [ \ get_option_specs('hp_tune_criterion', False, 'ml', 'Which criterion to use when tuning hyper-parameters. Other ' + 'options are post_sampling and post_mean.'), get_option_specs('hp_tune_probs', False, 'uniform', \ 'With what probability should we choose each strategy given in hp_tune_criterion.' + \ 'If "uniform" we we will use uniform probabilities and if "adaptive" we will use ' + \ 'adaptive probabilities which weight acquisitions according to how well they do.'), get_option_specs('ml_hp_tune_opt', False, 'direct', 'Which optimiser to use when maximising the tuning criterion.'), get_option_specs('hp_tune_max_evals', False, -1, 'How many evaluations to use when maximising the tuning criterion.'), get_option_specs('handle_non_psd_kernels', False, 'guaranteed_psd', 'How to handle kernels that are non-psd.'), # The mean and noise variance of the GP get_option_specs('mean_func_type', False, 'tune', ('Specify the type of mean function. Should be mean, median, const ', 'zero, or tune. If const, specifcy value in mean-func-const.')), get_option_specs('mean_func_const', False, 0.0, 'The constant value to use if mean_func_type is const.'), get_option_specs('noise_var_type', False, 'tune', \ ('Specify how to obtain the noise variance. Should be tune, label or value. ' \ 'Specify appropriate value in noise_var_label or noise_var_value')), get_option_specs('noise_var_label', False, 0.05, 'The fraction of label variance to use as noise variance.'), get_option_specs('noise_var_value', False, 0.1, 'The (absolute) value to use as noise variance.'), get_option_specs('post_hp_tune_method', False, 'slice', 'Which sampling to use when maximising the tuning criterion. Other ' + 'option is nuts.'), get_option_specs('post_hp_tune_burn', False, -1, 'How many initial samples to ignore during sampling.'), get_option_specs('post_hp_tune_offset', False, 25, 'How many samples to ignore between samples.'), \ ]
from argparse import Namespace import numpy as np # Local imports from chemist_opt import gpb_acquisitions from chemist_opt.blackbox_optimiser import blackbox_opt_args, BlackboxOptimiser from gp.gp_core import GP from gp.gp_instances import SimpleGPFitter, all_simple_gp_args from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter gp_bandit_args = [ # Acquisition get_option_specs( 'acq', False, 'ei', 'Which acquisition to use: ts, ucb, ei, ttei, bucb, ucbpe. If using multiple ' + 'give them as a hyphen separated list e.g. ucb-ts-ei-ttei'), get_option_specs( 'acq_probs', False, 'uniform', 'With what probability should we choose each strategy given in acq.'), get_option_specs( 'acq_opt_method', False, 'rand', 'Which optimiser to use when maximising the acquisition function.'), get_option_specs( 'handle_parallel', False, 'halluc', 'How to handle parallelisations. Should be halluc or naive.'), get_option_specs( 'acq_opt_max_evals', False, -1, 'Number of evaluations when maximising acquisition. If negative uses default value.' ), # The following are perhaps not so important.
import numpy as np # Local imports from opt.blackbox_optimiser import blackbox_opt_args from opt import gpb_acquisitions from nn.nn_gp import nn_gp_args, NNGPFitter from nn.nn_modifiers import get_nn_modifier_from_args from nn.nn_comparators import get_default_otmann_distance from opt.nn_opt_utils import get_initial_pool from opt.gp_bandit import GPBandit, gp_bandit_args from utils.general_utils import block_augment_array from utils.reporters import get_reporter from utils.option_handler import get_option_specs, load_options nasbot_specific_args = [ get_option_specs( 'nasbot_acq_opt_method', False, 'ga', 'Which method to use when optimising the acquisition. Will override acq_opt_method' + ' in the arguments for gp_bandit.'), get_option_specs( 'ga_mutation_op_distro', False, 'd0.5-0.25-0.125-0.075-0.05', 'Which method to use when optimising the acquisition. Will override acq_opt_method' + ' in the arguments for gp_bandit.'), ] all_nasbot_args = nasbot_specific_args + gp_bandit_args + \ blackbox_opt_args + nn_gp_args all_nn_random_bandit_args = all_nasbot_args # NN GP Bandit Class -------------------------------------------------------------------- class NASBOT(GPBandit): """ NN GP Bandit. """
# pylint: disable=arguments-differ import numpy as np # Local from gp import gp_core from gp.gp_instances import basic_gp_args from nn import nn_comparators from utils.ancillary_utils import get_list_of_floats_as_str from utils.reporters import get_reporter from utils.option_handler import get_option_specs, load_options _DFLT_KERNEL_TYPE = 'lpemd_sum' nn_gp_specific_args = [ get_option_specs( 'dist_type', False, 'lp-emd', 'The type of distance. This should be lp, emd or lp-emd.'), # Use given coeffcients by default get_option_specs('choose_mislabel_struct_coeffs', False, 'use_given', ( 'How to choose the mislabel and struct coefficients. Should be one of ' + 'tune_coeffs or use_given. In the latter case, mislabel_coeffs and struct_coeffs ' + 'should be non-empty.')), get_option_specs( 'compute_kernel_from_dists', False, True, 'Should you compute the kernel from pairwise distances whenever possible.' ), get_option_specs( 'mislabel_coeffs', False, '1.0-1.0-1.0-1.0', 'The mislabel coefficients specified as a string. If -1, it means we will tune.' ),
""" import numpy as np from mols.mol_kernels import MolKernel from gp import gp_core from gp.gp_instances import basic_gp_args from utils.ancillary_utils import get_list_of_floats_as_str from utils.reporters import get_reporter from utils.option_handler import get_option_specs, load_options _DFLT_KERNEL_TYPE = 'wl_kernel' # dict: name, required, default, help -> these values mol_gp_specific_args = [ get_option_specs( 'cont_par', False, '0.1-0.25-0.61-1.5', 'Continuous parameter for single-parameter kernels. for If -1, it means we will tune.' ), get_option_specs( 'int_par', False, 3, 'Integer parameter for single-parameter kernels. for If -1, it means we will tune.' ), # get_option_specs('non_assignment_penalty', False, 1.0, # 'The non-assignment penalty.'), ] # check what these should be mol_gp_args = gp_core.mandatory_gp_args + basic_gp_args + mol_gp_specific_args # GP implementation for molecules --------------------------------------------- class MolGP(gp_core.GP):
# pylint: disable=no-member # pylint: disable=invalid-name # pylint: disable=abstract-class-little-used from argparse import Namespace import time import numpy as np # Local imports from opt.function_caller import EVAL_ERROR_CODE from nn.nn_examples import generate_many_neural_networks from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter blackbox_opt_args = [ get_option_specs('max_num_steps', False, 1e7, 'If exceeds this many evaluations, stop.'), get_option_specs('capital_type', False, 'return_value', 'Should be one of return_value, cputime, or realtime'), get_option_specs('num_init_evals', False, 20, ( 'The number of evaluations for initialisation. If <0, will use default.' )), get_option_specs( 'mode', False, 'asy', 'If \'syn\', uses synchronous parallelisation, else asynchronous.'), get_option_specs( 'build_new_model_every', False, 7, 'Updates the GP via a suitable procedure every this many iterations.'), get_option_specs('report_results_every', False, 1, 'Report results every this many iterations.'), ]
from copy import deepcopy import time import numpy as np # Local imports from mf_func import MFOptFunction from mf_gp import all_mf_gp_args, MFGPFitter from mf_gpb_utils import acquisitions, fidelity_choosers from mf_gpb_utils import is_an_opt_fidel_query, latin_hc_sampling from utils.optimisers import direct_ft_maximise, random_maximise from utils.option_handler import get_option_specs, load_options from utils.reporters import get_reporter mf_gp_bandit_args = [ get_option_specs('capital_type', False, 'given', ( 'The type of capital to be used. If \'given\', it will use the cost specified. ' 'Could be one of given, cputime, or realtime')), get_option_specs( 'max_iters', False, 1e5, 'The maximum number of iterations, regardless of capital.'), get_option_specs('gamma_0', False, '1', ( 'The multiplier in front of the default threshold value for switching. Should be', 'a scalar or the string \'adapt\'.')), get_option_specs( 'acq', False, 'mf_gp_ucb', 'Which acquisition to use. Should be one of mf_gp_ucb, gp_ucb or gp_ei' ), get_option_specs( 'acq_opt_criterion', False, 'rand', 'Which optimiser to use when maximising the acquisition function.'), get_option_specs(