def test_pipeline_set_one_hyperparam_level_two_dict():
p = Pipeline([
("a", SomeStep()),
("b", Pipeline([
("a", SomeStep()),
("b", SomeStep()),
("c", SomeStep())
])),
("c", SomeStep())
])
p.set_hyperparams({
"b": {
"a": {
"learning_rate": 7
},
"learning_rate": 9
}
})
print(p.get_hyperparams())
assert p["b"]["a"].hyperparams["learning_rate"] == 7
assert p["b"]["c"].hyperparams == dict()
assert p["b"].hyperparams["learning_rate"] == 9
assert p["c"].hyperparams == dict()
def test_hyperparam_space():
p = Pipeline([
AddFeatures([
SomeStep(hyperparams_space=HyperparameterSpace({"n_components": RandInt(1, 5)})),
SomeStep(hyperparams_space=HyperparameterSpace({"n_components": RandInt(1, 5)}))
]),
ModelStacking([
SomeStep(hyperparams_space=HyperparameterSpace({"n_estimators": RandInt(1, 1000)})),
SomeStep(hyperparams_space=HyperparameterSpace({"n_estimators": RandInt(1, 1000)})),
SomeStep(hyperparams_space=HyperparameterSpace({"max_depth": RandInt(1, 100)})),
SomeStep(hyperparams_space=HyperparameterSpace({"max_depth": RandInt(1, 100)}))
],
joiner=NumpyTranspose(),
judge=SomeStep(hyperparams_space=HyperparameterSpace({"alpha": LogUniform(0.1, 10.0)}))
)
])
rvsed = p.get_hyperparams_space()
p.set_hyperparams(rvsed)
hyperparams = p.get_hyperparams()
assert "AddFeatures" in hyperparams.keys()
assert "SomeStep" in hyperparams["AddFeatures"]
assert "n_components" in hyperparams["AddFeatures"]["SomeStep"]
assert "SomeStep1" in hyperparams["AddFeatures"]
assert "n_components" in hyperparams["AddFeatures"]["SomeStep1"]
assert "SomeStep" in hyperparams["ModelStacking"]
assert "n_estimators" in hyperparams["ModelStacking"]["SomeStep"]
assert "SomeStep1" in hyperparams["ModelStacking"]
assert "max_depth" in hyperparams["ModelStacking"]["SomeStep2"]
def main():
p = Pipeline([
('step1', MultiplyByN()),
('step2', MultiplyByN()),
Pipeline([
Identity(),
Identity(),
PCA(n_components=4)
])
])
p.set_hyperparams_space({
'step1__multiply_by': RandInt(42, 50),
'step2__multiply_by': RandInt(-10, 0),
'Pipeline__PCA__n_components': RandInt(2, 3)
})
samples = p.get_hyperparams_space().rvs()
p.set_hyperparams(samples)
samples = p.get_hyperparams().to_flat_as_dict_primitive()
assert 42 <= samples['step1__multiply_by'] <= 50
assert -10 <= samples['step2__multiply_by'] <= 0
assert samples['Pipeline__PCA__n_components'] in [2, 3]
assert p['Pipeline']['PCA'].get_wrapped_sklearn_predictor().n_components in [2, 3]
def test_pipeline_set_one_hyperparam_level_one_dict():
p = Pipeline([("a", SomeStep()), ("b", SomeStep()), ("c", SomeStep())])
p.set_hyperparams({"b": {"learning_rate": 7}})
assert p["a"].hyperparams == dict()
assert p["b"].hyperparams["learning_rate"] == 7
assert p["c"].hyperparams == dict()
def test_pipeline_set_one_hyperparam_level_one_flat():
p = Pipeline([("a", SomeStep()), ("b", SomeStep()), ("c", SomeStep())])
p.set_hyperparams({"a__learning_rate": 7})
assert p["a"].hyperparams.to_flat_as_dict_primitive()["learning_rate"] == 7
assert p["b"].hyperparams.to_flat_as_dict_primitive() == dict()
assert p["c"].hyperparams.to_flat_as_dict_primitive() == dict()
def test_pipeline_update_hyperparam_level_one_dict():
p = Pipeline([("a", SomeStep()), ("b", SomeStep()), ("c", SomeStep())])
p.set_hyperparams({"b": {"learning_rate": 7, "other_hp": 8}})
p.update_hyperparams({"b": {"learning_rate": 0.01}})
assert p["b"].hyperparams["learning_rate"] == 0.01
assert p["b"].hyperparams["other_hp"] == 8
assert p["a"].hyperparams == dict()
assert p["c"].hyperparams == dict()
def test_pipeline_set_one_hyperparam_level_two_flat():
p = Pipeline([("a", SomeStep()),
("b",
Pipeline([("a", SomeStep()), ("b", SomeStep()),
("c", SomeStep())])), ("c", SomeStep())])
p.set_hyperparams({"b__a__learning_rate": 7})
print(p.get_hyperparams())
assert p["b"]["a"].hyperparams["learning_rate"] == 7
assert p["b"]["c"].hyperparams.to_flat_dict() == dict()
assert p["b"].hyperparams.to_flat_dict() == {'a__learning_rate': 7}
assert p["c"].hyperparams.to_flat_dict() == dict()
def test_hyperparam_space():
p = Pipeline([
AddFeatures([
SomeStep(hyperparams_space=HyperparameterSpace(
{"n_components": RandInt(1, 5)})),
SomeStep(hyperparams_space=HyperparameterSpace(
{"n_components": RandInt(1, 5)}))
]),
ModelStacking([
SomeStep(hyperparams_space=HyperparameterSpace(
{"n_estimators": RandInt(1, 1000)})),
SomeStep(hyperparams_space=HyperparameterSpace(
{"n_estimators": RandInt(1, 1000)})),
SomeStep(hyperparams_space=HyperparameterSpace(
{"max_depth": RandInt(1, 100)})),
SomeStep(hyperparams_space=HyperparameterSpace(
{"max_depth": RandInt(1, 100)}))
],
joiner=NumpyTranspose(),
judge=SomeStep(hyperparams_space=HyperparameterSpace(
{"alpha": LogUniform(0.1, 10.0)})))
])
rvsed = p.get_hyperparams_space()
p.set_hyperparams(rvsed)
hyperparams = p.get_hyperparams()
flat_hyperparams_keys = hyperparams.to_flat_dict().keys()
assert 'AddFeatures' in hyperparams
assert 'SomeStep' in hyperparams["AddFeatures"]
assert "n_components" in hyperparams["AddFeatures"]["SomeStep"]
assert 'SomeStep1' in hyperparams["AddFeatures"]
assert "n_components" in hyperparams["AddFeatures"]["SomeStep1"]
assert 'ModelStacking' in hyperparams
assert 'SomeStep' in hyperparams["ModelStacking"]
assert 'n_estimators' in hyperparams["ModelStacking"]["SomeStep"]
assert 'SomeStep1' in hyperparams["ModelStacking"]
assert 'n_estimators' in hyperparams["ModelStacking"]["SomeStep1"]
assert 'SomeStep2' in hyperparams["ModelStacking"]
assert 'max_depth' in hyperparams["ModelStacking"]["SomeStep2"]
assert 'SomeStep3' in hyperparams["ModelStacking"]
assert 'max_depth' in hyperparams["ModelStacking"]["SomeStep3"]
assert 'AddFeatures__SomeStep1__n_components' in flat_hyperparams_keys
assert 'AddFeatures__SomeStep__n_components' in flat_hyperparams_keys
assert 'ModelStacking__SomeStep__n_estimators' in flat_hyperparams_keys
assert 'ModelStacking__SomeStep1__n_estimators' in flat_hyperparams_keys
assert 'ModelStacking__SomeStep2__max_depth' in flat_hyperparams_keys
assert 'ModelStacking__SomeStep3__max_depth' in flat_hyperparams_keys
def test_pipeline_tosklearn():
import sklearn.pipeline
the_step = SomeStep()
step_to_check = the_step.tosklearn()
p = Pipeline([
("a", SomeStep()),
("b", SKLearnWrapper(sklearn.pipeline.Pipeline([
("a", sklearn.pipeline.Pipeline([
('z', step_to_check)
])),
("b", SomeStep().tosklearn()),
("c", SomeStep().tosklearn())
]), return_all_sklearn_default_params_on_get=True)),
("c", SomeStep())
])
# assert False
p.set_hyperparams({
"b": {
"a__z__learning_rate": 7,
"b__learning_rate": 9
}
})
assert the_step.get_hyperparams()["learning_rate"] == 7
p = p.tosklearn()
p = sklearn.pipeline.Pipeline([('sk', p)])
p.set_params(**{"sk__b__a__z__learning_rate": 11})
sk_ = p.named_steps["sk"]
b_ = sk_.p["b"]
predictor = b_.wrapped_sklearn_predictor
a_ = predictor.named_steps["a"]
z_ = a_["z"]
assert z_.get_params()["learning_rate"] == 11
p.set_params(**nested_dict_to_flat({
"sk__b": {
"a__z__learning_rate": 12,
"b__learning_rate": 9
}
}))
# p.set_params(**{"sk__b__a__z__learning_rate": 12})
assert p.named_steps["sk"].p["b"].wrapped_sklearn_predictor.named_steps["a"]["z"].get_params()[
"learning_rate"] == 12
print(the_step.get_hyperparams())
def test_pipeline_should_set_hyperparams():
p = Pipeline([
SomeStep().set_name('step_1'),
SomeStep().set_name('step_2')
])
p.set_hyperparams({
'hp': 1,
'step_1__hp': 2,
'step_2__hp': 3
})
assert isinstance(p.hyperparams, HyperparameterSamples)
assert p.hyperparams['hp'] == 1
assert p[0].hyperparams['hp'] == 2
assert p[1].hyperparams['hp'] == 3
def test_pipeline_update_hyperparam_level_two_flat():
p = Pipeline([("a", SomeStep()),
("b",
Pipeline([("a", SomeStep()), ("b", SomeStep()),
("c", SomeStep())])), ("c", SomeStep())])
p.set_hyperparams({
"b__a__learning_rate": 7,
"b__a__other_hp": 8,
})
p.update_hyperparams({"b__a__learning_rate": 0.01})
assert p["b"]["a"].hyperparams["learning_rate"] == 0.01
assert p["b"]["a"].hyperparams["other_hp"] == 8
assert p["b"]["c"].hyperparams == dict()
assert p["b"].hyperparams.to_flat_as_dict_primitive() == {
'a__learning_rate': 0.01,
'a__other_hp': 8
}
assert p["c"].hyperparams == dict()
