Exemple #1
0
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()
Exemple #6
0
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()
Exemple #8
0
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()
Exemple #10
0
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())
Exemple #11
0
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()
Exemple #12
0
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
Exemple #14
0
"""

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

Exemple #15
0
"""

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