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_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_slicing_both():
p = Pipeline([("a", SomeStep()), ("b", SomeStep()), ("c", SomeStep())])
r = p["b":"c"]
assert "a" not in r
assert "b" in r
assert "c" not in r
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_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_set_train_should_set_train_to_true():
pipeline = Pipeline([SomeStep(),
SomeStep(),
Pipeline([
SomeStep(),
])])
assert pipeline.is_train
assert pipeline[0].is_train
assert pipeline[1].is_train
assert pipeline[2].is_train
assert pipeline[2][0].is_train
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_set_train_should_set_train_to_false():
pipeline = Pipeline([SomeStep(),
SomeStep(),
Pipeline([
SomeStep(),
])])
pipeline.set_train(False)
assert not pipeline.is_train
assert not pipeline[0].is_train
assert not pipeline[1].is_train
assert not pipeline[2].is_train
assert not pipeline[2][0].is_train
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__SomeStep1__n_components' in hyperparams.keys()
assert 'AddFeatures__SomeStep__n_components' in hyperparams.keys()
assert 'AddFeatures__SomeStep1__n_components' in hyperparams.keys()
assert 'ModelStacking__SomeStep__n_estimators' in hyperparams.keys()
assert 'ModelStacking__SomeStep1__n_estimators' in hyperparams.keys()
assert 'ModelStacking__SomeStep2__max_depth' in hyperparams.keys()
assert 'ModelStacking__SomeStep3__max_depth' in 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_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()
def test_truncable_steps_should_split_by_type():
pipeline = Pipeline([
SomeStep(),
SomeStep(),
SomeSplitStep(),
SomeStep(),
SomeStep(),
SomeSplitStep(),
SomeStep(),
])
sub_pipelines = pipeline.split(SomeSplitStep)
assert 'SomeStep' in sub_pipelines[0]
assert 'SomeStep1' in sub_pipelines[0]
assert 'SomeSplitStep' in sub_pipelines[0]
assert 'SomeStep2' in sub_pipelines[1]
assert 'SomeStep3' in sub_pipelines[1]
assert 'SomeSplitStep1' in sub_pipelines[1]
assert 'SomeStep4' in sub_pipelines[2]
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
"""
import numpy as np
import pytest
from neuraxle.hyperparams.distributions import RandInt, LogUniform
from neuraxle.hyperparams.space import HyperparameterSpace, RecursiveDict
from neuraxle.pipeline import Pipeline
from neuraxle.steps.misc import TransformCallbackStep, TapeCallbackFunction
from neuraxle.steps.numpy import NumpyTranspose
from neuraxle.steps.sklearn import SKLearnWrapper
from neuraxle.union import Identity, AddFeatures, ModelStacking
from testing.mocks.step_mocks import SomeStep, AN_INPUT, AN_EXPECTED_OUTPUT
steps_lists = [[("just_one_step", SomeStep())],
[("some_step_1", SomeStep()), ("some_step_2", SomeStep()),
("some_step_3", SomeStep())]]
@pytest.mark.parametrize("steps_list", steps_lists)
def test_pipeline_fit_transform(steps_list):
data_input_ = [AN_INPUT]
expected_output_ = [AN_EXPECTED_OUTPUT]
p = Pipeline(steps_list)
p, result = p.fit_transform(data_input_, expected_output_)
assert tuple(result) == tuple(expected_output_)
"""
import numpy as np
import pytest
from neuraxle.hyperparams.distributions import RandInt, LogUniform
from neuraxle.hyperparams.space import nested_dict_to_flat, HyperparameterSpace
from neuraxle.pipeline import Pipeline
from neuraxle.steps.misc import TransformCallbackStep, TapeCallbackFunction
from neuraxle.steps.numpy import NumpyTranspose
from neuraxle.steps.sklearn import SKLearnWrapper
from neuraxle.union import Identity, AddFeatures, ModelStacking
from testing.mocks.step_mocks import SomeStep, AN_INPUT, AN_EXPECTED_OUTPUT
steps_lists = [
[("just_one_step", SomeStep())],
[
("some_step_1", SomeStep()),
("some_step_2", SomeStep()),
("some_step_3", SomeStep())
]
]
@pytest.mark.parametrize("steps_list", steps_lists)
def test_pipeline_fit_transform(steps_list):
data_input_ = [AN_INPUT]
expected_output_ = [AN_EXPECTED_OUTPUT]
p = Pipeline(steps_list)
p, result = p.fit_transform(data_input_, expected_output_)