raise def __repr__(self): return "Agent({_coconut_format_0})".format(_coconut_format_0=(self.name)) def get_defaults(self): """Get a dictionary of all default values to assign.""" defaults = {} if self.default is not self.NO_DEFAULT: defaults[self.name] = deepcopy(self.default) for name, val in self.extra_defaults.items(): defaults[name] = deepcopy(val) return defaults _coconut_call_set_names(Agent) def agent(name_or_agent_func=None, **kwargs): """Decorator for easily constructing agents. If a string is passed to the decorator it will use that as the name, otherwise the name is inferred from the name of the function. Examples: @agent() # or just @agent def x(env) = ... @agent("x") def x_agent(env) = ...
@_coconut_tco def resolve_against(self, other, **kwargs): """Attempt to perform a resolution against other else None.""" if isinstance(other, (Not, Or, Eq)): return _coconut_tail_call(other.resolve_against, self, **kwargs) elif (self.find_unification)(Not(other).simplify(**kwargs)) is not None: return bot else: return None def admits_empty_universe(self): """Determines if self allows for the possibility of an empty universe.""" return True _coconut_call_set_names(Expr) class Top(Expr): """True""" __slots__ = () @_coconut_tco def __eq__(self, other): return _coconut_tail_call(isinstance, other, Top) def __repr__(self): return "top" def __str__(self): return top_sym def __bool__(self):
reload(mixture_example) assert_improving(mixture_example.bb.get_data(print_data=True)) assert mixture_example.loss == want assert 0 <= mixture_example.loss < 85 assert (len)((set)((map)( _coconut_base_compose(_coconut.operator.itemgetter( ("memo")), (_coconut.operator.itemgetter(("alg")), 0)), mixture_example.bb.get_data()["examples"]))) > 1 assert mixture_example.bb.num_examples == NUM_TRIALS def test_json(self): print("\ntest json:") with using(json_data): from bbopt.examples import json_example assert round(json_example.y, 5) == 6 results = call_bbopt(json_file) want = min(get_nums(results, numtype=float)) assert os.path.exists(json_data) reload(json_example) assert_improving(json_example.bb.get_data(print_data=True)) assert json_example.y == want assert json_example.bb.num_examples == NUM_TRIALS _coconut_call_set_names(TestExamples) if __name__ == "__main__": unittest.main()
def assert_dict_or_callable_or_hashable(name, obj): """Assert obj is hashable, or for dicts apply recursively to values.""" if isinstance(obj, dict): for val in obj.values(): assert_dict_or_callable_or_hashable(name, val) elif not callable(obj): assert is_hashable( obj), "Constant " + name + " contains unhashable values" # Tests: class TestConstants(unittest.TestCase): def test_immutable(self): for name, value in vars(constants).items(): if not name.startswith("__"): assert not isinstance( value, list), "Constant " + name + " should be tuple, not list" assert not isinstance( value, set), "Constant " + name + " should be frozenset, not set" if "sentinel" not in name.lower(): assert_dict_or_callable_or_hashable(name, value) _coconut_call_set_names(TestConstants)
def __gt__(self, other): # type: (...) -> int return str(self) > str(other) def __ge__(self, other): # type: (...) -> int return str(self) >= str(other) def __le__(self, other): # type: (...) -> int return str(self) <= str(other) # Derived Classes: _coconut_call_set_names(Vars) class LowercasePropositions(Vars): a, b, c = props("a b c") d, e, f = props("d e f") g, h, i = props("g h i") j, k, l = props("j k l") m, n, o = props("m n o") p, q, r = props("p q r") s, t, u = props("s t u") v, w, x = props("v w x") y, z = props("y z") _coconut_call_set_names(LowercasePropositions)
data_points, losses = split_examples(new_examples, self.params) self.result = self.optimizer.tell(data_points, losses) current_point = self.optimizer.ask() self.current_values = make_values(self.params, current_point) @property def space(self): """The space over which optimization was performed.""" return self.optimizer.space @property def model(self): """Get the most recently fit model.""" return self.optimizer.models[-1] # Registered names: _coconut_call_set_names(SkoptBackend) SkoptBackend.register() SkoptBackend.register_alias("skopt") SkoptBackend.register_alg("gaussian_process", base_estimator="GP") SkoptBackend.register_alg("random_forest", base_estimator="RF") SkoptBackend.register_alg("extra_trees", base_estimator="ET") SkoptBackend.register_alg("gradient_boosted_regression_trees", base_estimator="GBRT") SkoptBackend.register_meta_for_all_algs("any_skopt")
_coconut_sys.path.pop(0) # Compiled Coconut: ----------------------------------------------------------- sys = _coconut_sys import numpy as np # patch in abc.ABC if it doesn't already exist import abc if not hasattr(abc, "ABC"): class ABC(_coconut.object): __metaclass__ = abc.ABCMeta _coconut_call_set_names(ABC) abc.ABC = ABC from pySOT.optimization_problems.optimization_problem import OptimizationProblem from pySOT.experimental_design import ExperimentalDesign from pySOT.experimental_design import LatinHypercube from pySOT.experimental_design import SymmetricLatinHypercube from pySOT.experimental_design import TwoFactorial from pySOT.surrogate import RBFInterpolant from pySOT.surrogate import GPRegressor from pySOT.surrogate.kernels import CubicKernel from pySOT.surrogate.kernels import LinearKernel from pySOT.surrogate.tails import ConstantTail from pySOT.surrogate.tails import LinearTail from pySOT.strategy import SRBFStrategy from pySOT.strategy import EIStrategy
cls.register_meta(alg_name, cls.registered_algs, meta_alg) @staticmethod def register_meta(alg_name, algs, meta_alg=constants.default_alg_sentinel): """Register an algorithm that defers to run_meta.""" meta_registry.register(alg_name, (algs, meta_alg)) @staticmethod def register_param_func(func_name, handler, placeholder_generator, support_check_func): """Register a new parameter definition function. See bbopt.params for examples.""" param_processor.register(func_name, handler, placeholder_generator, support_check_func) _coconut_call_set_names(Backend) class StandardBackend(Backend): """Base class for standard BBopt backends.""" def __init__(self, examples, params, *args, **kwargs): """Implement __init__ using setup_backend and tell_examples.""" self.init_fallback_backend() if not params: self.current_values = {} return self.setup_backend(params, *args, **kwargs) if examples:
if not _coconut_match_kwargs: _coconut_match_set_name_val = _coconut_match_temp_0 _coconut_match_check_2 = True if _coconut_match_check_2: if _coconut_match_set_name_val is not _coconut_sentinel: val = _coconut_match_temp_0 if _coconut_match_set_name_loss is not _coconut_sentinel: loss = _coconut_match_args[1][0] if _coconut_match_set_name_N is not _coconut_sentinel: N = _coconut_match_args[1][1] if not _coconut_match_check_2: raise _coconut_FunctionMatchError('ns = marginals |> starmap$(def (val, (loss, N)) -> N) |> np.asarray', _coconut_match_args) return N ns = (np.asarray)((starmap)(_coconut_lambda_2, marginals)) zs /= np.sqrt(ns) else: assert self.bandit_alg == "boltzmann", "invalid boltzmann bandit algorithm: {_coconut_format_0}".format(_coconut_format_0=(self.bandit_alg)) best_i = np.argmax(xs + zs) return marginals[best_i][0] # Registered names: _coconut_call_set_names(BanditBackend) BanditBackend.register() BanditBackend.register_alg("epsilon_greedy", bandit_alg="greedy") BanditBackend.register_alg("boltzmann_exploration", bandit_alg="boltzmann") BanditBackend.register_alg("boltzmann_gumbel_exploration", bandit_alg="boltzmann_gumbel")
_coconut_format_0=(name), _coconut_format_1=(i)), len(sampling_population), **proc_kwargs) sample.append(sampling_population.pop(ind)) return sample def shuffled(self, name, population, **kwargs): """Create a new parameter with the given name modeled by random.shuffle(population) except returned instead of modified in place.""" return self.sample(name, population, len(population), **kwargs) def shuffle(self, name, population, **kwargs): """Create a new parameter with the given name modeled by random.shuffle(population).""" population[:] = self.shuffled(name, population, **kwargs) def stdnormal(self, name, **kwargs): """Equivalent to bb.normalvariate(name, 0, 1).""" return self.normalvariate(name, 0, 1, **kwargs) # Array-based random functions: def rand(self, name, *shape, **kwargs): """Create a new array parameter for the given name and shape modeled by np.random.rand.""" return array_param(self.random, name, shape, kwargs) def randn(self, name, *shape, **kwargs): """Create a new array parameter for the given name and shape modeled by np.random.randn.""" return array_param(self.stdnormal, name, shape, kwargs) _coconut_call_set_names(BlackBoxOptimizer)
"""Get all items in the registry as (name, value) pairs.""" self.run_all_gens() _coconut_yield_from_7 = _coconut.iter(self.registered.items()) while True: try: yield _coconut.next(_coconut_yield_from_7) except _coconut.StopIteration as _coconut_yield_err_3: _coconut_yield_from_6 = _coconut_yield_err_3.args[ 0] if _coconut.len(_coconut_yield_err_3.args) > 0 else None break _coconut_yield_from_6 def asdict(self): """Convert registry to dictionary.""" self.run_all_gens() return self.registered # Registries: _coconut_call_set_names(Registry) backend_registry = Registry("backend") alg_registry = Registry("algorithm") meta_registry = Registry("meta algorithm") alg_registry.shouldnt_conflict_with(meta_registry) meta_registry.shouldnt_conflict_with(alg_registry)
except constants.erroring_backend_errs: if not self.remove_erroring_algs: raise self.reselect_backend() return self.param(name, func, *args, **kwargs) @classmethod def register_safe_alg_for(cls, base_alg, new_alg_name=None, fallback_alg=None): """Register a version of base_alg that defaults to the fallback if base_alg fails.""" if new_alg_name is None: new_alg_name = "safe_" + base_alg if fallback_alg is None: fallback_alg = constants.safe_fallback_alg cls.register_alg(new_alg_name, distribution=((base_alg, float("inf")), (fallback_alg, 1)), remove_erroring_algs=True) # Registered names: _coconut_call_set_names(MixtureBackend) MixtureBackend.register() MixtureBackend.register_alg("epsilon_max_greedy", distribution="epsilon_max_greedy") MixtureBackend.register_safe_alg_for("gaussian_process") MixtureBackend.register_safe_alg_for("random_forest") MixtureBackend.register_safe_alg_for("extra_trees") MixtureBackend.register_safe_alg_for("gradient_boosted_regression_trees") # we register meta alg mixtures here MixtureBackend.register_meta("tpe_or_gp", ("tree_structured_parzen_estimator", "safe_gaussian_process")) MixtureBackend.register_meta("any_fast", ("tree_structured_parzen_estimator", "safe_random_forest", "safe_extra_trees", "safe_gradient_boosted_regression_trees"))
return newsubs class counter(_coconut.object): def __init__(self, num=-1): self.num = num def inc(self): assert not self.done(), self.num self.num -= 1 def done(self): return self.num == 0 _coconut_call_set_names(counter) @_coconut_tco def sub_once(obj, subs): """Performs one substitution of subs into obj.""" return _coconut_tail_call(obj.substitute, subs, counter=counter(1)) def can_sub(kwargs): """Determines if the counter in kwargs allows for another sub.""" try: return not kwargs["counter"].done() except KeyError: return True
def standardize_kwargs(self, kwargs): """Standardizes param keyword args.""" return (fmap)(lambda k, v: denumpy_all((k, v)), kwargs) def choose_default_placeholder(self, name, func, *args, **kwargs): """Choose a default placeholder_when_missing value for the given parameter.""" if func not in self.placeholder_funcs: raise ValueError( "unknown parameter definition function {_coconut_format_0} (register with bbopt.params.param_processor.register)" .format(_coconut_format_0=(func))) return self.placeholder_funcs[func](*args) # Registration: _coconut_call_set_names(ParamProcessor) param_processor = ParamProcessor() param_processor.register("randrange", handle_randrange, placeholder_randrange, support_check_randrange) param_processor.register("choice", handle_choice, placeholder_choice, support_check_choice) param_processor.register("uniform", handle_uniform, placeholder_uniform, support_check_uniform) param_processor.register("triangular", handle_triangular, placeholder_triangular, support_check_triangular) param_processor.register("betavariate", handle_betavariate, placeholder_betavariate, support_check_betavariate) param_processor.register("expovariate", handle_expovariate, placeholder_expovariate, support_check_expovariate) param_processor.register("gammavariate", handle_gammavariate,
self.trials.refresh() # run one iteration of hyperparameter optimization, with values saved # to the self.set_current_values callback passed to Domain next(self.fmin_iter) assert self.current_values is not None, self.current_values assert set(self.current_values.keys()) == set( self.params), self.current_values def set_current_values(self, values): """Callback to set the values for this run.""" assert isinstance(values, dict), values self.current_values = values return {"status": STATUS_RUNNING} # Registered names: _coconut_call_set_names(HyperoptBackend) HyperoptBackend.register() HyperoptBackend.register_alg("tree_structured_parzen_estimator", algo=tpe.suggest) HyperoptBackend.register_alg("annealing", algo=anneal.suggest) if sys.version_info >= (3, ): from hyperopt import atpe HyperoptBackend.register_alg("adaptive_tpe", algo=atpe.suggest) HyperoptBackend.register_meta_for_all_algs("any_hyperopt")
def append(self, obj): self.new_list.append(obj) if obj not in self.old_list: self.old_list.append(obj) def __setitem__(self, index, obj): self.new_list[index] = obj if obj not in self.old_list: self.old_list.append(obj) def __repr__(self): return "ListProxy(\n\tself.old_list={_coconut_format_0},\n\tself.new_list={_coconut_format_1},\n)".format(_coconut_format_0=(self.old_list), _coconut_format_1=(self.new_list)) _coconut_call_set_names(ListProxy) class DictProxy(_coconut.object): """Behaves like new_dict, but adds new keys to old_dict.""" def __init__(self, old_dict, new_dict): self.old_dict = old_dict self.new_dict = new_dict def __iter__(self): _coconut_yield_from_3 = _coconut.iter(self.new_dict) while True: try: yield _coconut.next(_coconut_yield_from_3) except _coconut.StopIteration as _coconut_yield_err_1: _coconut_yield_from_2 = _coconut_yield_err_1.args[0] if _coconut.len(_coconut_yield_err_1.args) > 0 else None break
import random from bbopt.backends.util import Backend # Backend: class RandomBackend(Backend): """The random backend chooses parameter values randomly.""" backend_name = "random" random_functions = {"randrange": random.randrange, "choice": random.choice, "uniform": random.uniform, "triangular": random.triangular, "betavariate": random.betavariate, "expovariate": random.expovariate, "gammavariate": random.gammavariate, "normalvariate": random.gauss, "vonmisesvariate": random.vonmisesvariate, "paretovariate": random.paretovariate, "weibullvariate": random.weibullvariate} @override def param(self, name, func, *args, **kwargs): if func not in self.random_functions: raise ValueError("unknown random function {_coconut_format_0}".format(_coconut_format_0=(name))) return self.random_functions[func](*args) @override def attempt_update(self, examples, params): """The random backend requires no modifications to be updated with new parameters.""" return True # Registered names: _coconut_call_set_names(RandomBackend) RandomBackend.register() RandomBackend.register_alg("random")
from bask import Optimizer from bbopt.backends.skopt import SkoptBackend from bbopt.backends.skopt import create_dimensions from bbopt.backends.skopt import guess_n_initial_points # Backend: class BaskBackend(SkoptBackend): """The bask backend uses bayes-skopt for black box optimization.""" backend_name = "bayes-skopt" @override def setup_backend(self, params, n_initial_points=None, **options): """Special method to initialize the backend from params.""" self.params = params if n_initial_points is None: n_initial_points = guess_n_initial_points(params) self.optimizer = Optimizer(create_dimensions(params), n_initial_points=n_initial_points, **options) # Registered names: _coconut_call_set_names(BaskBackend) BaskBackend.register() BaskBackend.register_alias("bask") BaskBackend.register_alg("bask_gaussian_process")
# since we're serving, ignore params and just extract the best example self.current_values = best_example(examples)["values"] # set new allow_missing_data and call init_fallback_backend if necessary self.allow_missing_data = allow_missing_data if not self.fallback_backend and self.allow_missing_data: self.init_fallback_backend() return True @override def fallback_func(self, name, func, *args, **kwargs): if self.allow_missing_data: return super().fallback_func(name, func, *args, **kwargs) else: raise ValueError( "missing data for parameter {_coconut_format_0} while serving and no guess" .format(_coconut_format_0=(name))) # Registered names: _coconut_call_set_names(ServingBackend) ServingBackend.register() # allow_missing_data=False not included to help bb._backend_store ServingBackend.register_alg(None) ServingBackend.register_alg("serving") ServingBackend.register_alg("max_greedy", allow_missing_data=True)
equality = (call)(Eq, term + equals + term) atom = pred | prop | equality expr = Forward() quant_sep = dot | comma exists = ((call)(exists_handle, exists_op + var + Optional(colon + prop) + quant_sep + expr)) forall = ((call)(forall_handle, forall_op + var + Optional(colon + prop) + quant_sep + expr)) quant = exists | forall base_expr = top_lit | bot_lit | quant | atom | lparen - expr - rparen not_expr = quant | ((call)(Not, not_op + base_expr)) | base_expr | quant and_expr = quant | ((call)(And, not_expr + OneOrMore(and_op - not_expr))) | not_expr or_expr = quant | ((call)(Or, and_expr + OneOrMore(or_op - and_expr))) | and_expr expr <<= quant | ((call)(Implies, or_expr + OneOrMore(imp_op - or_expr))) | or_expr formula = stringStart + expr + stringEnd _coconut_call_set_names(Grammar) for varname, val in vars(Grammar).items(): if isinstance(val, ParserElement): setattr(Grammar, varname, val.setName(varname)) # Endpoint: def expr(formula): """Parses the given formula into an expression.""" result = parse(Grammar.formula, formula) assert len(result) == 1, results return result[0]