def test_categorical_transform():
categories = ["apple", "orange", "banana", None, True, False, 3]
cat = Categorical(categories)
apple = [1., 0., 0., 0., 0., 0., 0.]
orange = [0., 1.0, 0.0, 0.0, 0., 0., 0.]
banana = [0., 0., 1., 0., 0., 0., 0.]
none = [0., 0., 0., 1., 0., 0., 0.]
true = [0., 0., 0., 0., 1., 0., 0.]
false = [0., 0., 0., 0., 0., 1., 0.]
three = [0., 0., 0., 0., 0., 0., 1.]
assert_equal(cat.transformed_size, 7)
assert_equal(cat.transformed_size, cat.transform(["apple"]).size)
assert_array_equal(cat.transform(categories),
[apple, orange, banana, none, true, false, three])
assert_array_equal(cat.transform(["apple", "orange"]), [apple, orange])
assert_array_equal(cat.transform(["apple", "banana"]), [apple, banana])
assert_array_equal(cat.inverse_transform([apple, orange]),
["apple", "orange"])
assert_array_equal(cat.inverse_transform([apple, banana]),
["apple", "banana"])
ent_inverse = cat.inverse_transform(
[apple, orange, banana, none, true, false, three])
assert_array_equal(ent_inverse, categories)
def test_categorical_repr():
small_cat = Categorical([1, 2, 3, 4, 5])
assert (small_cat.__repr__() ==
"Categorical(categories=(1, 2, 3, 4, 5), prior=None)")
big_cat = Categorical([1, 2, 3, 4, 5, 6, 7, 8])
assert (big_cat.__repr__() ==
'Categorical(categories=(1, 2, 3, ..., 6, 7, 8), prior=None)')
def test_categorical_identity():
categories = ["cat", "dog", "rat"]
cat = Categorical(categories, transform="identity")
samples = cat.rvs(100)
assert_true(all([t in categories for t in cat.rvs(100)]))
transformed = cat.transform(samples)
assert_array_equal(transformed, samples)
assert_array_equal(samples, cat.inverse_transform(transformed))
def __init__(self, configspace, **kwargs):
super().__init__(configspace,
reward_attribute=kwargs.get('reward_attribute'))
self.hp_ordering = configspace.get_hyperparameter_names(
) # fix order of hyperparams in configspace.
skopt_hpspace = []
for hp in self.hp_ordering:
hp_obj = configspace.get_hyperparameter(hp)
hp_type = str(type(hp_obj)).lower() # type of hyperparam
if 'integer' in hp_type:
hp_dimension = Integer(low=int(hp_obj.lower),
high=int(hp_obj.upper),
name=hp)
elif 'float' in hp_type:
if hp_obj.log: # log10-scale hyperparmeter
hp_dimension = Real(low=float(hp_obj.lower),
high=float(hp_obj.upper),
prior='log-uniform',
name=hp)
else:
hp_dimension = Real(low=float(hp_obj.lower),
high=float(hp_obj.upper),
name=hp)
elif 'categorical' in hp_type:
hp_dimension = Categorical(hp_obj.choices, name=hp)
elif 'ordinal' in hp_type:
hp_dimension = Categorical(hp_obj.sequence, name=hp)
else:
raise ValueError("unknown hyperparameter type: %s" % hp)
skopt_hpspace.append(hp_dimension)
skopt_keys = {
'base_estimator', 'n_random_starts', 'n_initial_points',
'acq_func', 'acq_optimizer', 'random_state', 'model_queue_size',
'acq_func_kwargs', 'acq_optimizer_kwargs'
}
skopt_kwargs = self._filter_skopt_kwargs(kwargs, skopt_keys)
self.bayes_optimizer = Optimizer(dimensions=skopt_hpspace,
**skopt_kwargs)
def test_space_consistency():
# Reals (uniform)
s1 = Space([Real(0.0, 1.0)]).rvs(n_samples=10, random_state=0)
s2 = Space([Real(0.0, 1.0)]).rvs(n_samples=10, random_state=0)
s3 = Space([Real(0, 1)]).rvs(n_samples=10, random_state=0)
s4 = Space([(0.0, 1.0)]).rvs(n_samples=10, random_state=0)
s5 = Space([(0.0, 1.0, "uniform")]).rvs(n_samples=10, random_state=0)
assert_array_equal(s1, s2)
assert_array_equal(s1, s3)
assert_array_equal(s1, s4)
assert_array_equal(s1, s5)
# Reals (log-uniform)
s1 = Space([Real(10**-3.0, 10**3.0,
prior="log-uniform")]).rvs(n_samples=10, random_state=0)
s2 = Space([Real(10**-3.0, 10**3.0,
prior="log-uniform")]).rvs(n_samples=10, random_state=0)
s3 = Space([Real(10**-3, 10**3, prior="log-uniform")]).rvs(n_samples=10,
random_state=0)
s4 = Space([(10**-3.0, 10**3.0, "log-uniform")]).rvs(n_samples=10,
random_state=0)
assert_array_equal(s1, s2)
assert_array_equal(s1, s3)
assert_array_equal(s1, s4)
# Integers
s1 = Space([Integer(1, 5)]).rvs(n_samples=10, random_state=0)
s2 = Space([Integer(1.0, 5.0)]).rvs(n_samples=10, random_state=0)
s3 = Space([(1, 5)]).rvs(n_samples=10, random_state=0)
assert_array_equal(s1, s2)
assert_array_equal(s1, s3)
# Categoricals
s1 = Space([Categorical(["a", "b", "c"])]).rvs(n_samples=10,
random_state=0)
s2 = Space([Categorical(["a", "b", "c"])]).rvs(n_samples=10,
random_state=0)
assert_array_equal(s1, s2)
def __init__(self):
self.aggregator_hetero = Categorical(categories=['mean', 'sum', 'max'],
name='aggregator_hetero')
self.aggregator_type = Categorical(
categories=['mean', 'mean_nn',
'pool_nn'], name='aggregator_type') # LSTM?
self.clicks_sample = Categorical(categories=[.2, .3, .4],
name='clicks_sample')
self.delta = Real(low=0.15,
high=0.35,
prior='log-uniform',
name='delta')
self.dropout = Real(low=0., high=0.8, prior='uniform', name='dropout')
self.embed_dim = Categorical(categories=[
'Very Small', 'Small', 'Medium', 'Large', 'Very Large'
],
name='embed_dim')
self.embedding_layer = Categorical(categories=[True, False],
name='embedding_layer')
self.lr = Real(low=1e-4, high=1e-2, prior='log-uniform', name='lr')
self.n_layers = Integer(low=3, high=5, name='n_layers')
self.neg_sample_size = Integer(low=700,
high=3000,
name='neg_sample_size')
self.norm = Categorical(categories=[True, False], name='norm')
self.popularity_importance = Categorical(
categories=['No', 'Small', 'Medium', 'Large'],
name='popularity_importance')
self.purchases_sample = Categorical(categories=[.4, .5, .6],
name='purchases_sample')
self.use_recency = Categorical(categories=[True, False],
name='use_recency')
# List all the attributes in a list.
# This is equivalent to [self.hidden_dim_HP, self.out_dim_HP ...]
self.dimensions = [
self.__getattribute__(attr) for attr in dir(self)
if '__' not in attr
]
self.default_parameters = [
'sum', 'mean_nn', .3, 0.266, .5, 'Medium', False, 0.00565, 3, 2500,
True, 'No', .5, True
]
def indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching buy strategy parameters.
"""
gene = list()
for i in range(DNA_SIZE):
# g = randint(0, 5)
# GodGenes = GodGenesGroup[g]
gene.append(Categorical(GodGenes, name=f'buy-indicator-{i}'))
gene.append(Categorical(GodGenes, name=f'buy-cross-{i}'))
gene.append(Integer(-1, 101, name=f'buy-int-{i}'))
gene.append(Real(-1.1, 1.1, name=f'buy-real-{i}'))
# Operations
# CA: Crossed Above, CB: Crossed Below,
# I: Integer, R: Real, D: Disabled
gene.append(
Categorical([
"D", ">", "<", "=", "CA", "CB", ">I", "=I", "<I", ">R",
"=R", "<R"
],
name=f'buy-oper-{i}'))
return gene
def get_param_space(classifier_identifier):
'''
Returns hyperpameter seach space with prior probability distributions
[classifier_identifier] : str, one of 'kNN', 'LR', or 'SVM'
'''
if classifier_identifier == 'kNN':
param_space = [
Categorical(np.arange(1, 16, 2), name='kNN__n_neighbors'),
Categorical(['cosine', 'euclidean', 'manhattan'],
name='kNN__metric'),
]
elif classifier_identifier == 'LR':
param_space = [
Real(1e2, 1e4, prior="log-uniform", name='C'),
]
elif classifier_identifier == 'SVM':
param_space = [
Real(0.1, 10, prior="log-uniform", name='C'),
]
else:
ValueError('Invalid classifier identifier!')
return param_space
def indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching strategy parameters
"""
buyTriggerList = []
for short in range(shortRangeBegin, shortRangeEnd):
for medium in range(mediumRangeBegin, mediumRangeEnd):
"""
The output will be '{short}-{long}' so we can split it on the trigger
this will prevent an error on scikit-optimize not accepting tuples as
first argument to Categorical
"""
buyTriggerList.append('{}-{}'.format(short, medium))
return [Categorical(buyTriggerList, name='trigger')]
def sell_indicator_space() -> List[Dimension]:
sellTriggerList = ["rsi-macd-minusdi", "sar-fisherRsi"]
return [
Integer(rsiValueMin, rsiValueMax, name='rsi-sell-value'),
Integer(minusdiValueMin,
minusdiValueMax,
name='minusdi-sell-value'),
Integer(fishRsiNormaValueMin,
fishRsiNormaValueMax,
name='fishRsiNorma-sell-value'),
Categorical(sellTriggerList, name='sell-trigger')
]
def indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching strategy parameters
"""
buyTriggerList = []
for short in range(shortRangeBegin, shortRangeEnd):
for medium in range(mediumRangeBegin, mediumRangeEnd):
# The output will be (short, long)
buyTriggerList.append(
(short, medium)
)
return [
Categorical(buyTriggerList, name='trigger')
]
def get_sk_dimensions(api_config, transform="normalize"):
"""Help routine to setup skopt search space in constructor.
Take api_config as argument so this can be static.
"""
# The ordering of iteration prob makes no difference, but just to be
# safe and consistnent with space.py, I will make sorted.
param_list = sorted(api_config.keys())
sk_dims = []
round_to_values = {}
for param_name in param_list:
param_config = api_config[param_name]
param_type = param_config["type"]
param_space = param_config.get("space", None)
param_range = param_config.get("range", None)
param_values = param_config.get("values", None)
# Some setup for case that whitelist of values is provided:
values_only_type = param_type in ("cat", "ordinal")
if (param_values is not None) and (not values_only_type):
assert param_range is None
param_values = np.unique(param_values)
param_range = (param_values[0], param_values[-1])
round_to_values[param_name] = interp1d(
param_values, param_values, kind="nearest", fill_value="extrapolate"
)
if param_type == "int":
# Integer space in sklearn does not support any warping => Need
# to leave the warping as linear in skopt.
sk_dims.append(Integer(param_range[0], param_range[-1], transform=transform, name=param_name))
elif param_type == "bool":
assert param_range is None
assert param_values is None
sk_dims.append(Integer(0, 1, transform=transform, name=param_name))
elif param_type in ("cat", "ordinal"):
assert param_range is None
# Leave x-form to one-hot as per skopt default
sk_dims.append(Categorical(param_values, name=param_name))
elif param_type == "real":
# Skopt doesn't support all our warpings, so need to pick
# closest substitute it does support.
prior = "log-uniform" if param_space in ("log", "logit") else "uniform"
sk_dims.append(Real(param_range[0], param_range[-1], prior=prior, transform=transform, name=param_name))
else:
assert False, "type %s not handled in API" % param_type
return sk_dims, round_to_values
def test_categorical_only():
from skopt.space import Categorical
cat1 = Categorical([2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
cat2 = Categorical([2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
opt = Optimizer([cat1, cat2])
for n in range(15):
x = opt.ask()
res = opt.tell(x, 12 * n)
assert len(res.x_iters) == 15
next_x = opt.ask(n_points=4)
assert len(next_x) == 4
cat3 = Categorical(["2", "3", "4", "5", "6", "7", "8", "9", "10", "11"])
cat4 = Categorical(["2", "3", "4", "5", "6", "7", "8", "9", "10", "11"])
opt = Optimizer([cat3, cat4])
for n in range(15):
x = opt.ask()
res = opt.tell(x, 12 * n)
assert len(res.x_iters) == 15
next_x = opt.ask(n_points=4)
assert len(next_x) == 4
def indicator_space() -> List[Dimension]:
return [
Integer(0, 100, name='consensus-buy'),
# Informative Timeframe
Categorical(['lower', 'upper', 'both', 'none'], name='inf-guard'),
Real(0.70, 0.99, name='inf-pct-adr-top'),
Real(0.01, 0.20, name='inf-pct-adr-bot'),
# Extra BTC/ETH Stakes
Integer(10, 70, name='xtra-inf-stake-rmi'),
Integer(10, 70, name='xtra-base-stake-rmi'),
Integer(10, 70, name='xtra-base-fiat-rmi'),
# Extra BTC/STAKE if not in whitelist
Integer(0, 100, name='xbtc-consensus-buy')
]
def hyperopt2skopt_space(hyperopt_space, sample_size=1000):
skopt_space = []
ind2names = []
rng = np.random.RandomState()
for node_name, node in hyperopt_space.items():
ind2names.append(node_name)
if not isinstance(node, Apply):
skopt_space.append(Categorical([node], transform='identity'))
continue
dimention = node2supported_dimention(node)
if dimention is None:
dimention = node2sampled_dimention(node, rng, sample_size)
skopt_space.append(dimention)
return skopt_space, ind2names
def sell_indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching sell strategy parameters.
"""
buyTriggerList = []
for short in range(shortRangeBegin, shortRangeEnd, 5):
for medium in range(mediumRangeBegin, mediumRangeEnd, 10):
# The output will be (short, long)
buyTriggerList.append(
f"{short}.{medium}"
)
return [
Categorical(buyTriggerList, name='sell-trigger')
]
def test_categorical_string():
categories = [1, 2, 3]
categories_transformed = ["1", "2", "3"]
cat = Categorical(categories, transform="string")
samples = cat.rvs(100)
assert all([t in categories for t in cat.rvs(100)])
transformed = cat.transform(samples)
assert all([t in categories_transformed for t in transformed])
assert_array_equal(samples, cat.inverse_transform(transformed))
def test_plots_work():
"""Basic smoke tests to make sure plotting doesn't crash."""
SPACE = [
Integer(1, 20, name='max_depth'),
Integer(2, 100, name='min_samples_split'),
Integer(5, 30, name='min_samples_leaf'),
Integer(1, 30, name='max_features'),
Categorical(['gini', 'entropy'], name='criterion'),
Categorical(list('abcdefghij'), name='dummy'),
]
def objective(params):
clf = DecisionTreeClassifier(random_state=3,
**{
dim.name: val
for dim, val in zip(SPACE, params)
if dim.name != 'dummy'
})
return -np.mean(cross_val_score(clf, *load_breast_cancer(True)))
res = gp_minimize(objective, SPACE, n_calls=10, random_state=3)
x_min, f_min = expected_minimum_random_sampling(res, random_state=1)
x_min2, f_min2 = expected_minimum(res, random_state=1)
assert x_min == x_min2
assert f_min == f_min2
plots.plot_convergence(res)
plots.plot_evaluations(res)
plots.plot_objective(res)
plots.plot_objective(res, minimum='expected_minimum_random')
plots.plot_objective(res,
sample_source='expected_minimum_random',
n_minimum_search=10000)
plots.plot_objective(res, sample_source='result')
plots.plot_regret(res)
def random_forest(attributes, prediction):
x_train, x_test, y_train, y_test = train_test_split(attributes,
prediction,
random_state=0)
rf = RandomForestRegressor(n_estimators=200, random_state=42)
opt = BayesSearchCV(rf, {
'n_estimators': Integer(200, 2000),
'max_features': Categorical(['auto', 'sqrt']),
'max_depth': Integer(10, 110),
'min_samples_split': Integer(2, 10),
'min_samples_leaf': Integer(1, 4),
'bootstrap': Categorical([True, False]),
},
n_iter=32,
cv=5,
n_jobs=-1,
verbose=2)
opt.fit(x_train, y_train)
print("val. score: %s" % opt.best_score_)
print("test score: %s" % opt.score(x_test, y_test))
params_from_bayes = opt.best_params_
bayes_rf = RandomForestRegressor(**params_from_bayes)
scoring = ['accuracy', 'precision', 'recall', 'roc_auc', 'f1']
bayes_scores = cross_validate(bayes_rf,
attributes,
prediction,
scoring=scoring,
cv=10)
print(simplify_scores(bayes_scores))
def hpscan():
space = [
#Integer(25, 25), #name ='epochs'),
#Integer(5, 8), #name ='batch_size'),
#Integer(8, 10), #name='latent size'),
Categorical([1, 2, 5, 6, 8]), #name='gen_weight'),
Categorical([0.1, 0.2, 1, 2, 10]), #name='aux_weight'),
Categorical([0.1, 0.2, 1, 2, 10]), #name='ecal_weight'),
#Real(10**-5, 10**0, "log-uniform"), #name ='lr'),
#Real(8, 9), #name='rho'),
#Real(0, 0.0001), #name='decay'),
#Categorical([True,False]), #name='dflag'),
#Integer(4, 64), #name='df'),
#Integer(2, 16), #name='dx'),
#Integer(2, 16), #name='dy'),
#Integer(2, 16), #name='dz'),
#Real(0.01, 0.5), #name='dp'),
#Categorical([True,False]), #name='gflag'),
#Integer(4, 64), #name='gf'),
#Integer(2, 16), #name='gx'),
#Integer(2, 16), #name='gy'),
#Integer(2, 16)] #name='gz')
]
res_gp = gp_minimize(evaluate,
space,
n_calls=15,
n_random_starts=5,
verbose=True,
random_state=0)
"Best score=%.4f" % res_gp.fun
print("""Best parameters:
Loss Weights:
_ Weight Gen loss ={}
_ Weight Aux loss ={}
_ Weight Ecal loss ={}
""".format(res_gp.x[0], res_gp.x[1], res_gp.x[2]))
plot_convergence(res_gp)
def normalize_dimensions(dimensions):
"""Create a ``Space`` where all dimensions are normalized to unit range.
This is particularly useful for Gaussian process based regressors and is
used internally by ``gp_minimize``.
Parameters
----------
dimensions : list, shape (n_dims,)
List of search space dimensions.
Each search dimension can be defined either as
- a `(lower_bound, upper_bound)` tuple (for `Real` or `Integer`
dimensions),
- a `(lower_bound, upper_bound, "prior")` tuple (for `Real`
dimensions),
- as a list of categories (for `Categorical` dimensions), or
- an instance of a `Dimension` object (`Real`, `Integer` or
`Categorical`).
NOTE: The upper and lower bounds are inclusive for `Integer`
dimensions.
"""
space = Space(dimensions)
transformed_dimensions = []
for dimension in space.dimensions:
if isinstance(dimension, Categorical):
transformed_dimensions.append(
Categorical(dimension.categories,
dimension.prior,
name=dimension.name,
transform="normalize"))
# To make sure that GP operates in the [0, 1] space
elif isinstance(dimension, Real):
transformed_dimensions.append(
Real(dimension.low,
dimension.high,
dimension.prior,
name=dimension.name,
transform="normalize",
dtype=dimension.dtype))
elif isinstance(dimension, Integer):
transformed_dimensions.append(
Integer(dimension.low,
dimension.high,
name=dimension.name,
transform="normalize",
dtype=dimension.dtype))
else:
raise RuntimeError("Unknown dimension type "
"(%s)" % type(dimension))
return Space(transformed_dimensions)
def trailing_space() -> List[Dimension]:
"""
Create a trailing stoploss space.
You may override it in your custom Hyperopt class.
"""
return [
# It was decided to always set trailing_stop is to True if the 'trailing' hyperspace
# is used. Otherwise hyperopt will vary other parameters that won't have effect if
# trailing_stop is set False.
# This parameter is included into the hyperspace dimensions rather than assigning
# it explicitly in the code in order to have it printed in the results along with
# other 'trailing' hyperspace parameters.
Categorical([True], name='trailing_stop'),
Real(0.01, 0.35, name='trailing_stop_positive'),
# 'trailing_stop_positive_offset' should be greater than 'trailing_stop_positive',
# so this intermediate parameter is used as the value of the difference between
# them. The value of the 'trailing_stop_positive_offset' is constructed in the
# generate_trailing_params() method.
# This is similar to the hyperspace dimensions used for constructing the ROI tables.
Real(0.001, 0.1, name='trailing_stop_positive_offset_p1'),
Categorical([True, False], name='trailing_only_offset_is_reached'),
]
def gdb_bayes_grid():
""" Defines hyper parameters for gradient decent boost """
# define variables to include in parameter grid for scikit-learn CV functions
# Define parameter grid for skopt BayesSearchCV
bayes_grid = {
'n_estimators': Integer(500, 2000),
'max_features': Categorical(['auto', 'sqrt']),
'max_depth': Integer(1, 25),
'min_samples_split': Integer(2, 30),
'min_samples_leaf': Integer(2, 30),
'learning_rate': Real(0.001, 1, 'log-uniform')
}
return bayes_grid
def space_xlearn():
space = [
Integer(300, 1000, name='block_size'),
Real(0.005, 0.1, name='lr'),
Integer(4, 20, name='k'),
Real(0.01, 0.5, name='reg_lambda'),
Real(0.01, 0.5, name='init'),
Integer(4, 50, name='epoch'),
Categorical(['adagrad', 'ftrl'], name='opt'),
Real(0.1, 2.5, name='alpha'),
Real(0.1, 2.5, name='beta'),
Real(0.1, 2.5, name='lambda_1'),
Real(0.1, 2.5, name='lambda_2'),
]
return space
def indicator_space() -> List[Dimension]:
buyTriggerList = ["True"]
return [
Integer(volumeAvgValueMin,
volumeAvgValueMax,
name='volumeAVG-buy-value'),
Integer(rsiValueMin, rsiValueMax, name='rsi-buy-value'),
Integer(fastdValueMin, fastdValueMax, name='fastd-buy-value'),
Integer(fishRsiNormaValueMin,
fishRsiNormaValueMax,
name='fishRsiNorma-buy-value'),
Categorical(buyTriggerList, name='buy-trigger')
]
def get_optimizer(config, features):
return Optimizer(
[
Categorical(categories=[0, 1], name=f, prior=[0.75, 0.25])
for f in features
],
#[Integer(low=0, high=1, name=f) for f in features],
base_estimator=config.get('base_estimator', 'ET'),
acq_optimizer=config.get('acq_optimizer', 'sampling'),
n_random_starts=config.get('n_random_starts', None),
n_initial_points=config.get('n_initial_points', 10),
acq_func=config.get('acq_func', 'gp_hedge'),
random_state=config.get('random_state', None),
acq_func_kwargs=config.get('acq_func_kwargs', None),
acq_optimizer_kwargs=config.get('acq_optimizer_kwargs', None))
def _knob_to_dimension(knob):
if isinstance(knob, CategoricalKnob):
return Categorical([x.value for x in knob.values])
elif isinstance(knob, IntegerKnob):
return Integer(knob.value_min, knob.value_max)
elif isinstance(knob, FloatKnob):
if knob.is_exp:
# Avoid error in skopt when low/high are 0
value_min = knob.value_min if knob.value_min != 0 else 1e-12
value_max = knob.value_max if knob.value_max != 0 else 1e-12
return Real(value_min, value_max, 'log-uniform')
else:
return Real(knob.value_min, knob.value_max, 'uniform')
else:
raise UnsupportedKnobError(knob.__class__)
def space_lightgbm():
space = [
Categorical(['gbdt', 'gbrt', 'dart', 'goss'], name='boosting_type'),
Integer(150, 1500, name="num_leaves"),
Integer(5, 25, name='max_depth'),
Real(0.005, 0.05, "log-uniform", name='learning_rate'),
Integer(100, 1000, name="max_bin"),
Integer(250, 2500, name="n_estimators"),
Real(0.6, 0.9, name="bagging_fraction"),
Real(0.6, 0.9, name="colsample_bytree"),
Real(2., 20., name="min_child_weight"),
Integer(25, 50, name="min_child_samples"),
Real(0.1, 0.5, name="reg_alpha"),
]
return space
def build_search_space(hyperparameter_space):
space = []
for name, subspace in hyperparameter_space.items():
parameter_type = subspace[0]
parameters = subspace[1:]
if parameter_type == 'Real':
space.append(Real(*parameters, name=name))
elif parameter_type == 'Integer':
space.append(Integer(*parameters, name=name))
elif parameter_type == 'Categorical':
space.append(Categorical(*parameters, name=name))
else:
ValueError(
'{} is not a valid parameter_type'.format(parameter_type))
return space
def test_searchcv_runs(surrogate, n_jobs, n_points, cv=None):
"""
Test whether the cross validation search wrapper around sklearn
models runs properly with available surrogates and with single
or multiple workers and different number of parameter settings
to ask from the optimizer in parallel.
Parameters
----------
* `surrogate` [str or None]:
A class of the scikit-optimize surrogate used. None means
to use default surrogate.
* `n_jobs` [int]:
Number of parallel processes to use for computations.
"""
X, y = load_iris(True)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.75,
random_state=0)
# create an instance of a surrogate if it is not a string
if surrogate is not None:
optimizer_kwargs = {'base_estimator': surrogate}
else:
optimizer_kwargs = None
opt = BayesSearchCV(SVC(), {
'C': Real(1e-6, 1e+6, prior='log-uniform'),
'gamma': Real(1e-6, 1e+1, prior='log-uniform'),
'degree': Integer(1, 8),
'kernel': Categorical(['linear', 'poly', 'rbf']),
},
n_jobs=n_jobs,
n_iter=11,
n_points=n_points,
cv=cv,
optimizer_kwargs=optimizer_kwargs)
opt.fit(X_train, y_train)
# this normally does not hold only if something is wrong
# with the optimizaiton procedure as such
assert opt.score(X_test, y_test) > 0.9
def indicator_space() -> List[Dimension]:
return [
# Base Timeframe
Integer(15, 70, name='base-rmi-slow'),
Integer(10, 50, name='base-rmi-fast'),
Integer(10, 70, name='base-mp'),
# Informative Timeframe
Integer(10, 70, name='inf-rsi'),
Categorical(['lower', 'upper', 'both', 'none'], name='inf-guard'),
Real(0.70, 0.99, name='inf-pct-adr-top'),
Real(0.01, 0.20, name='inf-pct-adr-bot'),
# Exra BTC/ETH Stakes
Integer(10, 70, name='xtra-inf-stake-rmi'),
Integer(50, 90, name='xtra-base-stake-rsi'),
Integer(10, 70, name='xtra-base-fiat-rsi')
]
def test_categorical_transform_binary():
categories = ["apple", "orange"]
cat = Categorical(categories)
apple = [0.]
orange = [1.]
assert_equal(cat.transformed_size, 1)
assert_equal(cat.transformed_size, cat.transform(["apple"]).size)
assert_array_equal(cat.transform(categories), [apple, orange])
assert_array_equal(cat.transform(["apple", "orange"]), [apple, orange])
assert_array_equal(cat.inverse_transform([apple, orange]),
["apple", "orange"])
ent_inverse = cat.inverse_transform([apple, orange])
assert_array_equal(ent_inverse, categories)
def test_categorical_transform():
categories = ["apple", "orange", "banana"]
cat = Categorical(categories)
apple = [1.0, 0.0, 0.0]
banana = [0., 1., 0.]
orange = [0., 0., 1]
assert_array_equal(cat.transform(categories), [apple, orange, banana])
assert_array_equal(cat.transform(["apple", "orange"]), [apple, orange])
assert_array_equal(cat.transform(["apple", "banana"]), [apple, banana])
assert_array_equal(cat.inverse_transform([apple, orange]),
["apple", "orange"])
assert_array_equal(cat.inverse_transform([apple, banana]),
["apple", "banana"])
ent_inverse = cat.inverse_transform([apple, orange, banana])
assert_array_equal(ent_inverse, categories)
def check_categorical(vals, random_val):
x = Categorical(vals)
assert_equal(x.rvs(random_state=1), random_val)
