def resolve_value(domain: Domain) -> Tuple: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): precision = quantize or 1e-12 if isinstance(sampler, Uniform): return (ValueType.CONTINUOUS, [domain.lower, domain.upper], precision) elif isinstance(domain, Integer): if isinstance(sampler, Uniform): return (ValueType.DISCRETE, [domain.lower, domain.upper], True) elif isinstance(domain, Categorical): # Categorical variables would use ValueType.DISCRETE with # has_partial_order=False, however, currently we do not # keep track of category values and cannot automatically # translate back and forth between them. if isinstance(sampler, Uniform): return (ValueType.GRID, domain.categories) raise ValueError("ZOOpt does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(domain: Domain) -> Union[Tuple, List]: sampler = domain.get_sampler() if isinstance(sampler, Quantized): logger.warning("SkOpt search does not support quantization. " "Dropped quantization.") sampler = sampler.get_sampler() if isinstance(domain, Float): if isinstance(domain.sampler, LogUniform): return sko.space.Real(domain.lower, domain.upper, prior="log-uniform") return sko.space.Real(domain.lower, domain.upper, prior="uniform") elif isinstance(domain, Integer): if isinstance(domain.sampler, LogUniform): return sko.space.Integer(domain.lower, domain.upper - 1, prior="log-uniform") return sko.space.Integer(domain.lower, domain.upper - 1, prior="uniform") elif isinstance(domain, Categorical): return sko.space.Categorical(domain.categories) raise ValueError("SkOpt does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(domain: Domain) -> Union[Tuple, List]: sampler = domain.get_sampler() if isinstance(sampler, Quantized): logger.warning("SkOpt search does not support quantization. " "Dropped quantization.") sampler = sampler.get_sampler() if isinstance(domain, Float): if domain.sampler is not None: logger.warning( "SkOpt does not support specific sampling methods." " The {} sampler will be dropped.".format(sampler)) return domain.lower, domain.upper if isinstance(domain, Integer): if domain.sampler is not None: logger.warning( "SkOpt does not support specific sampling methods." " The {} sampler will be dropped.".format(sampler)) return domain.lower, domain.upper if isinstance(domain, Categorical): return domain.categories raise ValueError("SkOpt does not support parameters of type " "`{}`".format(type(domain).__name__))
def resolve_value(domain: Domain) -> Parameter: sampler = domain.get_sampler() if isinstance(sampler, Quantized): logger.warning( "Nevergrad does not support quantization. Dropped quantization." ) sampler = sampler.get_sampler() if isinstance(domain, Float): if isinstance(sampler, LogUniform): return ng.p.Log(lower=domain.lower, upper=domain.upper, exponent=sampler.base) return ng.p.Scalar(lower=domain.lower, upper=domain.upper) elif isinstance(domain, Integer): if isinstance(sampler, LogUniform): return ng.p.Log( lower=domain.lower, upper=domain.upper - 1, # Upper bound exclusive exponent=sampler.base, ).set_integer_casting() return ng.p.Scalar( lower=domain.lower, upper=domain.upper - 1, # Upper bound exclusive ).set_integer_casting() elif isinstance(domain, Categorical): return ng.p.Choice(choices=domain.categories) raise ValueError("Nevergrad does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value( par: str, domain: Domain) -> ConfigSpace.hyperparameters.Hyperparameter: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): if isinstance(sampler, LogUniform): lower = domain.lower upper = domain.upper if quantize: lower = math.ceil(domain.lower / quantize) * quantize upper = math.floor(domain.upper / quantize) * quantize return ConfigSpace.UniformFloatHyperparameter(par, lower=lower, upper=upper, q=quantize, log=True) elif isinstance(sampler, Uniform): lower = domain.lower upper = domain.upper if quantize: lower = math.ceil(domain.lower / quantize) * quantize upper = math.floor(domain.upper / quantize) * quantize return ConfigSpace.UniformFloatHyperparameter(par, lower=lower, upper=upper, q=quantize, log=False) elif isinstance(sampler, Normal): return ConfigSpace.NormalFloatHyperparameter( par, mu=sampler.mean, sigma=sampler.sd, q=quantize, log=False) elif isinstance(domain, Integer): if isinstance(sampler, Uniform): lower = domain.lower upper = domain.upper if quantize: lower = math.ceil(domain.lower / quantize) * quantize upper = math.floor(domain.upper / quantize) * quantize return ConfigSpace.UniformIntegerHyperparameter( par, lower=lower, upper=upper, q=quantize, log=False) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return ConfigSpace.CategoricalHyperparameter( par, choices=domain.categories) raise ValueError("TuneBOHB does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(domain: Domain) -> ot.distributions.BaseDistribution: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(sampler, LogUniform): logger.warning( "Optuna does not handle quantization in loguniform " "sampling. The parameter will be passed but it will " "probably be ignored." ) if isinstance(domain, Float): if isinstance(sampler, LogUniform): if quantize: logger.warning( "Optuna does not support both quantization and " "sampling from LogUniform. Dropped quantization." ) return ot.distributions.LogUniformDistribution( domain.lower, domain.upper ) elif isinstance(sampler, Uniform): if quantize: return ot.distributions.DiscreteUniformDistribution( domain.lower, domain.upper, quantize ) return ot.distributions.UniformDistribution( domain.lower, domain.upper ) elif isinstance(domain, Integer): if isinstance(sampler, LogUniform): return ot.distributions.IntLogUniformDistribution( domain.lower, domain.upper - 1, step=quantize or 1 ) elif isinstance(sampler, Uniform): # Upper bound should be inclusive for quantization and # exclusive otherwise return ot.distributions.IntUniformDistribution( domain.lower, domain.upper - int(bool(not quantize)), step=quantize or 1, ) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return ot.distributions.CategoricalDistribution(domain.categories) raise ValueError( "Optuna search does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__ ) )
def resolve_value(par: str, domain: Domain): sampler = domain.get_sampler() if isinstance(sampler, Quantized): logger.warning( "HEBO search does not support quantization. " "Dropped quantization." ) sampler = sampler.get_sampler() if isinstance(domain, Float): if isinstance(sampler, LogUniform): return { "name": par, "type": "pow", "lb": domain.lower, "ub": domain.upper, "base": sampler.base, } elif isinstance(sampler, Uniform): return { "name": par, "type": "num", "lb": domain.lower, "ub": domain.upper, } elif isinstance(domain, Integer): if isinstance(sampler, LogUniform): return { "name": par, "type": "pow_int", "lb": domain.lower, "ub": domain.upper - 1, # Upper bound exclusive "base": sampler.base, } elif isinstance(sampler, Uniform): return { "name": par, "type": "int", "lb": domain.lower, "ub": domain.upper - 1, # Upper bound exclusive } elif isinstance(domain, Categorical): return { "name": par, "type": "cat", "categories": list(domain.categories), } raise ValueError( "HEBO does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__ ) )
def resolve_value(par: str, domain: Domain) -> Any: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): if isinstance(sampler, LogUniform): if quantize: return hpo.hp.qloguniform(par, domain.lower, domain.upper, quantize) return hpo.hp.loguniform(par, np.log(domain.lower), np.log(domain.upper)) elif isinstance(sampler, Uniform): if quantize: return hpo.hp.quniform(par, domain.lower, domain.upper, quantize) return hpo.hp.uniform(par, domain.lower, domain.upper) elif isinstance(sampler, Normal): if quantize: return hpo.hp.qnormal(par, sampler.mean, sampler.sd, quantize) return hpo.hp.normal(par, sampler.mean, sampler.sd) elif isinstance(domain, Integer): if isinstance(sampler, Uniform): if quantize: logger.warning( "HyperOpt does not support quantization for " "integer values. Reverting back to 'randint'.") return hpo.hp.randint(par, domain.lower, high=domain.upper) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return hpo.hp.choice(par, [ HyperOptSearch.convert_search_space( category, prefix=par) if isinstance(category, dict) else HyperOptSearch.convert_search_space( dict(enumerate(category)), prefix=f"{par}/{i}") if isinstance(category, list) else resolve_value( f"{par}/{i}", category) if isinstance(category, Domain) else category for i, category in enumerate(domain.categories) ]) raise ValueError("HyperOpt does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(par: str, domain: Domain) -> Any: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): if isinstance(sampler, LogUniform): if quantize: return hpo.hp.qloguniform(par, domain.lower, domain.upper, quantize) return hpo.hp.loguniform(par, np.log(domain.lower), np.log(domain.upper)) elif isinstance(sampler, Uniform): if quantize: return hpo.hp.quniform(par, domain.lower, domain.upper, quantize) return hpo.hp.uniform(par, domain.lower, domain.upper) elif isinstance(sampler, Normal): if quantize: return hpo.hp.qnormal(par, sampler.mean, sampler.sd, quantize) return hpo.hp.normal(par, sampler.mean, sampler.sd) elif isinstance(domain, Integer): if isinstance(sampler, Uniform): if quantize: logger.warning( "HyperOpt does not support quantization for " "integer values. Reverting back to 'randint'.") if domain.lower != 0: raise ValueError( "HyperOpt only allows integer sampling with " f"lower bound 0. Got: {domain.lower}.") if domain.upper < 1: raise ValueError( "HyperOpt does not support integer sampling " "of values lower than 0. Set your maximum range " "to something above 0 (currently {})".format( domain.upper)) return hpo.hp.randint(par, domain.upper) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return hpo.hp.choice(par, domain.categories) raise ValueError("HyperOpt does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(par: str, domain: Domain) -> Tuple: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): if isinstance(sampler, LogUniform): if quantize: logger.warning( "Optuna does not support both quantization and " "sampling from LogUniform. Dropped quantization.") return param.suggest_loguniform(par, domain.lower, domain.upper) elif isinstance(sampler, Uniform): if quantize: return param.suggest_discrete_uniform( par, domain.lower, domain.upper, quantize) return param.suggest_uniform(par, domain.lower, domain.upper) elif isinstance(domain, Integer): if isinstance(sampler, LogUniform): if quantize: logger.warning( "Optuna does not support both quantization and " "sampling from LogUniform. Dropped quantization.") return param.suggest_int(par, domain.lower, domain.upper, log=True) elif isinstance(sampler, Uniform): return param.suggest_int(par, domain.lower, domain.upper, step=quantize or 1) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return param.suggest_categorical(par, domain.categories) raise ValueError( "Optuna search does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(domain: Domain) -> ot.distributions.BaseDistribution: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): if isinstance(sampler, LogUniform): if quantize: logger.warning( "Optuna does not support both quantization and " "sampling from LogUniform. Dropped quantization.") return ot.distributions.LogUniformDistribution( domain.lower, domain.upper) elif isinstance(sampler, Uniform): if quantize: return ot.distributions.DiscreteUniformDistribution( domain.lower, domain.upper, quantize) return ot.distributions.UniformDistribution( domain.lower, domain.upper) elif isinstance(domain, Integer): if isinstance(sampler, LogUniform): return ot.distributions.IntLogUniformDistribution( domain.lower, domain.upper, step=quantize or 1) elif isinstance(sampler, Uniform): return ot.distributions.IntUniformDistribution( domain.lower, domain.upper, step=quantize or 1) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return ot.distributions.CategoricalDistribution( domain.categories) raise ValueError( "Optuna search does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__))
def resolve_value(par: str, domain: Domain) -> Dict: sampler = domain.get_sampler() if isinstance(sampler, Quantized): logger.warning( "Dragonfly search does not support quantization. " "Dropped quantization.") sampler = sampler.get_sampler() if isinstance(domain, Float): if domain.sampler is not None: logger.warning( "Dragonfly does not support specific sampling methods." " The {} sampler will be dropped.".format(sampler)) return { "name": par, "type": "float", "min": domain.lower, "max": domain.upper, } raise ValueError("Dragonfly does not support parameters of type " "`{}`".format(type(domain).__name__))
def resolve_value(par: str, domain: Domain) -> Any: quantize = None sampler = domain.get_sampler() if isinstance(sampler, Quantized): quantize = sampler.q sampler = sampler.sampler if isinstance(domain, Float): if isinstance(sampler, LogUniform): if quantize: return hpo.hp.qloguniform( par, np.log(domain.lower), np.log(domain.upper), quantize ) return hpo.hp.loguniform( par, np.log(domain.lower), np.log(domain.upper) ) elif isinstance(sampler, Uniform): if quantize: return hpo.hp.quniform( par, domain.lower, domain.upper, quantize ) return hpo.hp.uniform(par, domain.lower, domain.upper) elif isinstance(sampler, Normal): if quantize: return hpo.hp.qnormal(par, sampler.mean, sampler.sd, quantize) return hpo.hp.normal(par, sampler.mean, sampler.sd) elif isinstance(domain, Integer): if isinstance(sampler, LogUniform): if quantize: return hpo.base.pyll.scope.int( hpo.hp.qloguniform( par, np.log(domain.lower), np.log(domain.upper), quantize, ) ) return hpo.base.pyll.scope.int( hpo.hp.qloguniform( par, np.log(domain.lower), np.log(domain.upper - 1), 1.0 ) ) elif isinstance(sampler, Uniform): if quantize: return hpo.base.pyll.scope.int( hpo.hp.quniform( par, domain.lower, domain.upper - 1, quantize ) ) return hpo.hp.uniformint(par, domain.lower, high=domain.upper - 1) elif isinstance(domain, Categorical): if isinstance(sampler, Uniform): return hpo.hp.choice( par, [ HyperOptSearch.convert_search_space(category, prefix=par) if isinstance(category, dict) else HyperOptSearch.convert_search_space( dict(enumerate(category)), prefix=f"{par}/{i}" ) if isinstance(category, list) and len(category) > 0 and isinstance(category[0], Domain) else resolve_value(f"{par}/{i}", category) if isinstance(category, Domain) else category for i, category in enumerate(domain.categories) ], ) raise ValueError( "HyperOpt does not support parameters of type " "`{}` with samplers of type `{}`".format( type(domain).__name__, type(domain.sampler).__name__ ) )