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_)