def test_ask_advanced(self): """ Test advanced functionality of .ask() """ branch = Branch("branch") branch += PipelineElement("PCA") branch += PipelineElement("SVC", { "C": [0.1, 1], "kernel": ["rbf", "sigmoid"] }) pipe_switch = Switch( "switch", [ PipelineElement("StandardScaler"), PipelineElement("MaxAbsScaler") ], ) self.pipeline_elements = [ PipelineElement("StandardScaler"), PipelineElement( "PCA", hyperparameters={"n_components": IntegerRange(5, 20)}, test_disabled=True, ), pipe_switch, branch, Switch("Switch_in_switch", [branch, pipe_switch]), ] generated_elements = self.test_ask() self.assertIn("PCA__n_components", generated_elements) self.assertIn("Switch_in_switch__current_element", generated_elements) self.assertIn("branch__SVC__C", generated_elements) self.assertIn("branch__SVC__kernel", generated_elements) self.assertIn("switch__current_element", generated_elements)
def test_ask_advanced(self): """ Test advanced functionality of .ask() """ branch = Branch('branch') branch += PipelineElement('PCA') branch += PipelineElement('SVC', { 'C': [0.1, 1], 'kernel': ['rbf', 'sigmoid'] }) pipe_switch = Switch('switch', [ PipelineElement("StandardScaler"), PipelineElement("MaxAbsScaler") ]) self.pipeline_elements = [ PipelineElement("StandardScaler"), PipelineElement( 'PCA', hyperparameters={'n_components': IntegerRange(5, 20)}, test_disabled=True), pipe_switch, branch, Switch('Switch_in_switch', [branch, pipe_switch]) ] generated_elements = self.test_ask() self.assertIn("PCA__n_components", generated_elements) self.assertIn("Switch_in_switch__current_element", generated_elements) self.assertIn("branch__SVC__C", generated_elements) self.assertIn("branch__SVC__kernel", generated_elements) self.assertIn("switch__current_element", generated_elements)
def test_estimator_type(self): pca = PipelineElement('PCA') ica = PipelineElement('FastICA') svc = PipelineElement('SVC') svr = PipelineElement('SVR') tree_class = PipelineElement('DecisionTreeClassifier') tree_reg = PipelineElement('DecisionTreeRegressor') switch = Switch('MySwitch', [pca, svr]) with self.assertRaises(NotImplementedError): est_type = switch._estimator_type switch = Switch('MySwitch', [svc, svr]) with self.assertRaises(NotImplementedError): est_type = switch._estimator_type switch = Switch('MySwitch', [pca, ica]) self.assertEqual(switch._estimator_type, None) switch = Switch('MySwitch', [tree_class, svc]) self.assertEqual(switch._estimator_type, 'classifier') switch = Switch('MySwitch', [tree_reg, svr]) self.assertEqual(switch._estimator_type, 'regressor') self.assertEqual(self.estimator_switch._estimator_type, 'classifier') self.assertEqual(self.estimator_switch_with_branch._estimator_type, 'classifier') self.assertEqual(self.transformer_switch_with_branch._estimator_type, None) self.assertEqual(self.switch_in_switch._estimator_type, None)
def test_predict_proba(self): gpc = PipelineElement('GaussianProcessClassifier') svc = PipelineElement('SVC') switch = Switch('EstimatorSwitch', [gpc, svc]) switch.set_params(**{'current_element': (0, 0)}) np.random.seed(42) switch_probas = switch.fit(self.X, self.y).predict_proba(self.X) np.random.seed(42) gpr_probas = self.gpc.fit(self.X, self.y).predict_proba(self.X) self.assertTrue(np.array_equal(switch_probas, gpr_probas))
def setUp(self): self.svc_pipe_element = PipelineElement('SVC', {'C': [0.1, 1], 'kernel': ['rbf', 'sigmoid']}) self.lr_pipe_element = PipelineElement('DecisionTreeClassifier', {'min_samples_split': [2, 3, 4]}) self.pipe_switch = Switch('switch', [self.svc_pipe_element, self.lr_pipe_element]) self.branch = Branch('branch') self.branch += PipelineElement('PCA') self.branch += self.svc_pipe_element self.switch_in_switch = Switch('Switch_in_switch', [self.branch, self.pipe_switch])
def setUp(self): self.X, self.y = load_breast_cancer(True) self.svc = PipelineElement('SVC', { 'C': [0.1, 1], 'kernel': ['rbf', 'sigmoid'] }) self.tree = PipelineElement('DecisionTreeClassifier', {'min_samples_split': [2, 3, 4]}) self.gpc = PipelineElement('GaussianProcessClassifier') self.pca = PipelineElement('PCA') self.estimator_branch = Branch('estimator_branch', [self.tree.copy_me()]) self.transformer_branch = Branch('transformer_branch', [self.pca.copy_me()]) self.estimator_switch = Switch( 'estimator_switch', [self.svc.copy_me(), self.tree.copy_me(), self.gpc.copy_me()]) self.estimator_switch_with_branch = Switch( 'estimator_switch_with_branch', [self.tree.copy_me(), self.estimator_branch.copy_me()]) self.transformer_switch_with_branch = Switch( 'transformer_switch_with_branch', [self.pca.copy_me(), self.transformer_branch.copy_me()]) self.switch_in_switch = Switch('Switch_in_switch', [ self.transformer_branch.copy_me(), self.transformer_switch_with_branch.copy_me() ])
def test_copy_me(self): switch = Switch("my_copy_switch") switch += PipelineElement("StandardScaler") switch += PipelineElement("RobustScaler", test_disabled=True) stack = Stack("RandomStack") stack += PipelineElement("SVC") branch = Branch('Random_Branch') pca_hyperparameters = {'n_components': [5, 10]} branch += PipelineElement("PCA", hyperparameters=pca_hyperparameters) branch += PipelineElement("DecisionTreeClassifier") stack += branch photon_pipe = PhotonPipeline([("SimpleImputer", PipelineElement("SimpleImputer")), ("my_copy_switch", switch), ('RandomStack', stack), ('Callback1', CallbackElement('tmp_callback', np.mean)), ("PhotonVotingClassifier", PipelineElement("PhotonVotingClassifier"))]) copy_of_the_pipe = photon_pipe.copy_me() self.assertEqual(photon_pipe.random_state, copy_of_the_pipe.random_state) self.assertTrue(len(copy_of_the_pipe.elements) == 5) self.assertTrue(copy_of_the_pipe.elements[2][1].name == "RandomStack") self.assertTrue(copy_of_the_pipe.named_steps["my_copy_switch"].elements[1].test_disabled) self.assertDictEqual(copy_of_the_pipe.elements[2][1].elements[1].elements[0].hyperparameters, {"PCA__n_components": [5, 10]}) self.assertTrue(isinstance(copy_of_the_pipe.elements[3][1], CallbackElement)) self.assertTrue(copy_of_the_pipe.named_steps["tmp_callback"].delegate_function == np.mean)
def setup_crazy_pipe(self): # erase all, we need a complex and crazy task self.hyperpipe.elements = list() nmb_list = list() for i in range(5): nmb = NeuroBranch(name=str(i), nr_of_processes=i + 3) nmb += PipelineElement("SmoothImages") nmb_list.append(nmb) my_switch = Switch("disabling_test_switch") my_switch += nmb_list[0] my_switch += nmb_list[1] my_stack = Stack("stack_of_branches") for i in range(3): my_branch = Branch("branch_" + str(i + 2)) my_branch += PipelineElement("StandardScaler") my_branch += nmb_list[i + 2] my_stack += my_branch self.hyperpipe.add(my_stack) self.hyperpipe.add(PipelineElement("StandardScaler")) self.hyperpipe.add(my_switch) self.hyperpipe.add(PipelineElement("SVC")) return nmb_list
def test_classification_2(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # Simple estimator Switch switch = Switch("estimator_switch") switch += PipelineElement( "SVC", hyperparameters={ "kernel": Categorical(["linear", "rbf"]), "C": Categorical([0.01, 1, 5]), }, ) switch += PipelineElement( "RandomForestClassifier", hyperparameters={ "min_samples_split": FloatRange(start=0.05, step=0.1, stop=0.26, range_type="range") }, ) pipe += switch self.run_hyperpipe(pipe, self.classification)
def setup_crazy_pipe(self): # erase all, we need a complex and crazy task self.hyperpipe.elements = list() nmb_list = list() for i in range(5): nmb = ParallelBranch(name=str(i), nr_of_processes=i + 3) sp = PipelineElement( 'PCA', hyperparameters={'n_components': IntegerRange(1, 50)}) nmb += sp nmb_list.append(nmb) my_switch = Switch('disabling_test_switch') my_switch += nmb_list[0] my_switch += nmb_list[1] my_stack = Stack('stack_of_branches') for i in range(3): my_branch = Branch('branch_' + str(i + 2)) my_branch += PipelineElement('StandardScaler') my_branch += nmb_list[i + 2] my_stack += my_branch self.hyperpipe.add(my_stack) self.hyperpipe.add(PipelineElement('StandardScaler')) self.hyperpipe.add(my_switch) self.hyperpipe.add(PipelineElement('SVC')) return nmb_list
def setUp(self): self.svc_pipe_element = PipelineElement("SVC", { "C": [0.1, 1], "kernel": ["rbf", "sigmoid"] }) self.lr_pipe_element = PipelineElement( "DecisionTreeClassifier", {"min_samples_split": [2, 3, 4]}) self.pipe_switch = Switch( "switch", [self.svc_pipe_element, self.lr_pipe_element]) self.branch = Branch("branch") self.branch += PipelineElement("PCA") self.branch += self.svc_pipe_element self.switch_in_switch = Switch("Switch_in_switch", [self.branch, self.pipe_switch])
def test_class_switch(self): """ Test for Pipeline with data. """ X, y = load_breast_cancer(return_X_y=True) my_pipe = Hyperpipe( 'basic_switch_pipe', optimizer='random_grid_search', optimizer_params={'n_configurations': 15}, metrics=['accuracy', 'precision', 'recall'], best_config_metric='accuracy', outer_cv=KFold(n_splits=3), inner_cv=KFold(n_splits=5), verbosity=1, output_settings=OutputSettings(project_folder='./tmp/')) # Transformer Switch my_pipe += Switch('TransformerSwitch', [ PipelineElement('StandardScaler'), PipelineElement('PCA', test_disabled=True) ]) # Estimator Switch svm = PipelineElement('SVC', hyperparameters={'kernel': ['rbf', 'linear']}) tree = PipelineElement('DecisionTreeClassifier', hyperparameters={ 'min_samples_split': IntegerRange(2, 5), 'min_samples_leaf': IntegerRange(1, 5), 'criterion': ['gini', 'entropy'] }) my_pipe += Switch('EstimatorSwitch', [svm, tree]) json_transformer = JsonTransformer() pipe_json = json_transformer.create_json(my_pipe) my_pipe_reload = json_transformer.from_json(pipe_json) self.assertDictEqual(elements_to_dict(my_pipe.copy_me()), elements_to_dict(my_pipe_reload.copy_me()))
def test_classification_5(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # multi-switch # setup switch to choose between PCA or simple feature selection and add it to the pipe pre_switch = Switch("preproc_switch") pre_switch += PipelineElement( "PCA", hyperparameters={"n_components": Categorical([None, 5])}, test_disabled=True, ) pre_switch += PipelineElement( "FClassifSelectPercentile", hyperparameters={ "percentile": IntegerRange(start=5, step=20, stop=66, range_type="range") }, test_disabled=True, ) pipe += pre_switch # setup estimator switch and add it to the pipe estimator_switch = Switch("estimator_switch") estimator_switch += PipelineElement( "SVC", hyperparameters={ "kernel": Categorical(["linear", "rbf"]), "C": Categorical([0.01, 1, 5]), }, ) estimator_switch += PipelineElement( "RandomForestClassifier", hyperparameters={ "min_samples_split": FloatRange(start=0.05, step=0.1, stop=0.26, range_type="range") }, ) pipe += estimator_switch self.run_hyperpipe(pipe, self.classification)
def test_classification_3(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # estimator Switch without hyperparameters my_switch = Switch('estimator_switch') my_switch += PipelineElement('SVC') my_switch += PipelineElement('RandomForestClassifier') pipe += my_switch self.run_hyperpipe(pipe, self.classification)
def test_regression_3(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # estimator Switch without hyperparameters my_switch = Switch("estimator_switch") my_switch += PipelineElement("SVR") my_switch += PipelineElement("RandomForestRegressor") pipe += my_switch self.run_hyperpipe(pipe, self.regression)
def test_regression_4(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # Transformer Switch my_switch = Switch('trans_switch') my_switch += PipelineElement('PCA') my_switch += PipelineElement('FRegressionSelectPercentile', hyperparameters={'percentile': IntegerRange(start=5, step=20, stop=66, range_type='range')}, test_disabled=True) pipe += my_switch pipe += PipelineElement('RandomForestRegressor') self.run_hyperpipe(pipe, self.regression)
def test_classification_5(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # multi-switch # setup switch to choose between PCA or simple feature selection and add it to the pipe pre_switch = Switch('preproc_switch') pre_switch += PipelineElement('PCA', hyperparameters={'n_components': Categorical([None, 5])}, test_disabled=True) pre_switch += PipelineElement('FClassifSelectPercentile', hyperparameters={ 'percentile': IntegerRange(start=5, step=20, stop=66, range_type='range')}, test_disabled=True) pipe += pre_switch # setup estimator switch and add it to the pipe estimator_switch = Switch('estimator_switch') estimator_switch += PipelineElement('SVC', hyperparameters={'kernel': Categorical(['linear', 'rbf']), 'C': Categorical([.01, 1, 5])}) estimator_switch += PipelineElement('RandomForestClassifier', hyperparameters={ 'min_samples_split': FloatRange(start=.05, step=.1, stop=.26, range_type='range')}) pipe += estimator_switch self.run_hyperpipe(pipe, self.classification)
def test_classification_2(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # Simple estimator Switch switch = Switch('estimator_switch') switch += PipelineElement('SVC', hyperparameters={'kernel': Categorical(['linear', 'rbf']), 'C': Categorical([.01, 1, 5])}) switch += PipelineElement('RandomForestClassifier', hyperparameters={ 'min_samples_split': FloatRange(start=.05, step=.1, stop=.26, range_type='range')}) pipe += switch self.run_hyperpipe(pipe, self.classification)
def test_prepare_photon_pipeline(self): test_branch = Branch('my_test_branch') test_branch += PipelineElement('SimpleImputer') test_branch += Switch('my_crazy_switch_bitch') test_branch += Stack('my_stacking_stack') test_branch += PipelineElement('SVC') generated_pipe = test_branch.prepare_photon_pipe(test_branch.elements) self.assertEqual(len(generated_pipe.named_steps), 4) for idx, element in enumerate(test_branch.elements): self.assertIs(generated_pipe.named_steps[element.name], element) self.assertIs(generated_pipe.elements[idx][1], test_branch.elements[idx])
def test_add(self): self.assertEqual(len(self.estimator_switch.elements), 3) self.assertEqual(len(self.switch_in_switch.elements), 2) self.assertEqual(len(self.transformer_switch_with_branch.elements), 2) self.assertEqual( list(self.estimator_switch.elements_dict.keys()), ['SVC', 'DecisionTreeClassifier', 'GaussianProcessClassifier']) self.assertEqual( list(self.switch_in_switch.elements_dict.keys()), ['transformer_branch', 'transformer_switch_with_branch']) switch = Switch('MySwitch', [PipelineElement('PCA'), PipelineElement('FastICA')]) switch = Switch('MySwitch2') switch += PipelineElement('PCA') switch += PipelineElement('FastICA') # test doubled names with self.assertRaises(ValueError): self.estimator_switch += self.estimator_switch.elements[0] self.estimator_switch += PipelineElement("SVC") self.assertEqual(self.estimator_switch.elements[-1].name, "SVC2") self.estimator_switch += PipelineElement( "SVC", hyperparameters={'kernel': ['polynomial', 'sigmoid']}) self.assertEqual(self.estimator_switch.elements[-1].name, "SVC3") self.estimator_switch += PipelineElement("SVR") self.assertEqual(self.estimator_switch.elements[-1].name, "SVR") self.estimator_switch += PipelineElement("SVC") self.assertEqual(self.estimator_switch.elements[-1].name, "SVC4") # check that hyperparameters are renamed respectively self.assertEqual( self.estimator_switch.pipeline_element_configurations[4][0] ["SVC3__kernel"], 'polynomial')
def test_base_element(self): switch = Switch('switch', [self.svc, self.tree]) switch.set_params(**{'current_element': (1, 1)}) self.assertIs(switch.base_element, self.tree) self.assertIs(switch.base_element.base_element, self.tree.base_element) # other optimizer switch.set_params(**{'DecisionTreeClassifier__min_samples_split': 2}) self.assertIs(switch.base_element, self.tree) self.assertIs(switch.base_element.base_element, self.tree.base_element)
def test_classification_4(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # Transformer Switch my_switch = Switch("trans_switch") my_switch += PipelineElement("PCA") my_switch += PipelineElement( "FClassifSelectPercentile", hyperparameters={ "percentile": IntegerRange(start=5, step=20, stop=66, range_type="range") }, test_disabled=True, ) pipe += my_switch pipe += PipelineElement("RandomForestClassifier") self.run_hyperpipe(pipe, self.classification)
def test_classification_10(self): for original_hyperpipe in self.hyperpipes: pipe = original_hyperpipe.copy_me() # crazy everything pipe += PipelineElement('StandardScaler') pipe += PipelineElement('SamplePairingClassification', {'draw_limit': [100], 'generator': Categorical(['nearest_pair', 'random_pair'])}, distance_metric='euclidean', test_disabled=True) # setup pipeline branches with half of the features each # if both PCAs are disabled, features are simply concatenated and passed to the final estimator source1_branch = Branch('source1_features') # first half of features (for Boston Housing, same as indices=[0, 1, 2, 3, 4, 5] source1_branch += DataFilter(indices=np.arange(start=0, stop=int(np.floor(self.X_shape[1] / 2)))) source1_branch += PipelineElement('ConfounderRemoval', {}, standardize_covariates=True, test_disabled=True, confounder_names=['cov1', 'cov2']) source1_branch += PipelineElement('PCA', hyperparameters={'n_components': Categorical([None, 5])}, test_disabled=True) source2_branch = Branch('source2_features') # second half of features (for Boston Housing, same is indices=[6, 7, 8, 9, 10, 11, 12] source2_branch += DataFilter(indices=np.arange(start=int(np.floor(self.X_shape[1] / 2)), stop=self.X_shape[1])) source2_branch += PipelineElement('ConfounderRemoval', {}, standardize_covariates=True, test_disabled=True, confounder_names=['cov1', 'cov2']) source2_branch += PipelineElement('PCA', hyperparameters={'n_components': Categorical([None, 5])}, test_disabled=True) # setup source branches and stack their output (i.e. horizontal concatenation) pipe += Stack('source_stack', elements=[source1_branch, source2_branch]) # final estimator with stack output as features # setup estimator switch and add it to the pipe switch = Switch('estimator_switch') switch += PipelineElement('SVC', hyperparameters={'kernel': Categorical(['linear', 'rbf']), 'C': Categorical([.01, 1, 5])}) switch += PipelineElement('RandomForestClassifier', hyperparameters={ 'min_samples_split': FloatRange(start=.05, step=.1, stop=.26, range_type='range')}) pipe += switch self.run_hyperpipe(pipe, self.classification)
def test_set_random_state(self): # we handle all elements in one method that is inherited so we capture them all in this test random_state = 53 my_branch = Branch("random_state_branch") my_branch += PipelineElement("StandardScaler") my_switch = Switch("transformer_Switch") my_switch += PipelineElement("LassoFeatureSelection") my_switch += PipelineElement("PCA") my_branch += my_switch my_stack = Stack("Estimator_Stack") my_stack += PipelineElement("SVR") my_stack += PipelineElement("Ridge") my_branch += my_stack my_branch += PipelineElement("ElasticNet") my_branch.random_state = random_state self.assertTrue(my_switch.elements[1].random_state == random_state) self.assertTrue( my_switch.elements[1].base_element.random_state == random_state) self.assertTrue(my_stack.elements[1].random_state == random_state) self.assertTrue( my_stack.elements[1].base_element.random_state == random_state)
def test_add(self): stack = Stack('MyStack', [ PipelineElement('PCA', {'n_components': [5]}), PipelineElement('FastICA') ]) self.assertEqual(len(stack.elements), 2) self.assertDictEqual(stack._hyperparameters, {'MyStack__PCA__n_components': [5]}) stack = Stack('MyStack') stack += PipelineElement('PCA', {'n_components': [5]}) stack += PipelineElement('FastICA') self.assertEqual(len(stack.elements), 2) self.assertDictEqual(stack._hyperparameters, {'MyStack__PCA__n_components': [5]}) def callback(X, y=None): pass stack = Stack('MyStack', [ PipelineElement('PCA'), CallbackElement('MyCallback', callback), Switch('MySwitch', [PipelineElement('PCA'), PipelineElement('FastICA')]), Branch('MyBranch', [PipelineElement('PCA')]) ]) self.assertEqual(len(stack.elements), 4) # test doubled item with self.assertRaises(ValueError): stack += stack.elements[0] stack += PipelineElement('PCA', {'n_components': [10, 20]}) self.assertEqual(stack.elements[-1].name, 'PCA2') self.assertDictEqual( stack.hyperparameters, { 'MyStack__MySwitch__current_element': [(0, 0), (1, 0)], 'MyStack__PCA2__n_components': [10, 20] })
X, y = load_breast_cancer(True) # CREATE HYPERPIPE my_pipe = Hyperpipe('basic_switch_pipe', optimizer='random_grid_search', optimizer_params={'n_configurations': 15}, metrics=['accuracy', 'precision', 'recall'], best_config_metric='accuracy', outer_cv=KFold(n_splits=3), inner_cv=KFold(n_splits=5), verbosity=1, output_settings=OutputSettings(project_folder='./tmp/')) # Transformer Switch my_pipe += Switch('TransformerSwitch', [ PipelineElement('StandardScaler'), PipelineElement('PCA', test_disabled=True) ]) # Estimator Switch svm = PipelineElement('SVC', hyperparameters={'kernel': ['rbf', 'linear']}) tree = PipelineElement('DecisionTreeClassifier', hyperparameters={ 'min_samples_split': IntegerRange(2, 5), 'min_samples_leaf': IntegerRange(1, 5), 'criterion': ['gini', 'entropy'] }) my_pipe += Switch('EstimatorSwitch', [svm, tree]) my_pipe.fit(X, y)
"basic_switch_pipe", optimizer="random_grid_search", optimizer_params={"n_configurations": 15}, metrics=["accuracy", "precision", "recall"], best_config_metric="accuracy", outer_cv=KFold(n_splits=3), inner_cv=KFold(n_splits=5), verbosity=1, output_settings=OutputSettings(project_folder="./tmp/"), ) # Transformer Switch my_pipe += Switch( "TransformerSwitch", [ PipelineElement("StandardScaler"), PipelineElement("PCA", test_disabled=True) ], ) # Estimator Switch svm = PipelineElement("SVC", hyperparameters={"kernel": ["rbf", "linear"]}) tree = PipelineElement( "DecisionTreeClassifier", hyperparameters={ "min_samples_split": IntegerRange(2, 5), "min_samples_leaf": IntegerRange(1, 5), "criterion": ["gini", "entropy"], }, )
# DESIGN YOUR PIPELINE my_pipe = Hyperpipe('feature_selection', optimizer='grid_search', metrics=['mean_squared_error', 'pearson_correlation', 'mean_absolute_error', 'explained_variance'], best_config_metric='mean_squared_error', outer_cv=KFold(n_splits=3), inner_cv=KFold(n_splits=3), verbosity=1, output_settings=OutputSettings(project_folder='./tmp/')) my_pipe += PipelineElement('StandardScaler') lasso = PipelineElement('LassoFeatureSelection', hyperparameters={'percentile_to_keep': [0.1, 0.2, 0.3], 'alpha': 1}) f_regression = PipelineElement('FRegressionSelectPercentile', hyperparameters={'percentile': [10, 20, 30]}) my_pipe += Switch('FeatureSelection', [lasso, f_regression]) my_pipe += PipelineElement('RandomForestRegressor', hyperparameters={'n_estimators': IntegerRange(10, 50)}) my_pipe.fit(X, y)
class SwitchTests(unittest.TestCase): def setUp(self): self.X, self.y = load_breast_cancer(True) self.svc = PipelineElement('SVC', { 'C': [0.1, 1], 'kernel': ['rbf', 'sigmoid'] }) self.tree = PipelineElement('DecisionTreeClassifier', {'min_samples_split': [2, 3, 4]}) self.gpc = PipelineElement('GaussianProcessClassifier') self.pca = PipelineElement('PCA') self.estimator_branch = Branch('estimator_branch', [self.tree.copy_me()]) self.transformer_branch = Branch('transformer_branch', [self.pca.copy_me()]) self.estimator_switch = Switch( 'estimator_switch', [self.svc.copy_me(), self.tree.copy_me(), self.gpc.copy_me()]) self.estimator_switch_with_branch = Switch( 'estimator_switch_with_branch', [self.tree.copy_me(), self.estimator_branch.copy_me()]) self.transformer_switch_with_branch = Switch( 'transformer_switch_with_branch', [self.pca.copy_me(), self.transformer_branch.copy_me()]) self.switch_in_switch = Switch('Switch_in_switch', [ self.transformer_branch.copy_me(), self.transformer_switch_with_branch.copy_me() ]) def test_init(self): self.assertEqual(self.estimator_switch.name, 'estimator_switch') def test_hyperparams(self): # assert number of different configs to test # each config combi for each element: 4 for SVC and 3 for logistic regression = 7 self.assertEqual( len(self.estimator_switch.pipeline_element_configurations), 3) self.assertEqual( len(self.estimator_switch.pipeline_element_configurations[0]), 4) self.assertEqual( len(self.estimator_switch.pipeline_element_configurations[1]), 3) # hyperparameters self.assertDictEqual( self.estimator_switch.hyperparameters, { 'estimator_switch__current_element': [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (2, 0)] }) # config grid self.assertListEqual(self.estimator_switch.generate_config_grid(), [{ 'estimator_switch__current_element': (0, 0) }, { 'estimator_switch__current_element': (0, 1) }, { 'estimator_switch__current_element': (0, 2) }, { 'estimator_switch__current_element': (0, 3) }, { 'estimator_switch__current_element': (1, 0) }, { 'estimator_switch__current_element': (1, 1) }, { 'estimator_switch__current_element': (1, 2) }, { 'estimator_switch__current_element': (2, 0) }]) def test_set_params(self): # test for grid search false_config = {'current_element': 1} with self.assertRaises(ValueError): self.estimator_switch.set_params(**false_config) correct_config = {'current_element': (0, 1)} self.estimator_switch.set_params(**correct_config) self.assertEqual(self.estimator_switch.base_element.base_element.C, 0.1) self.assertEqual( self.estimator_switch.base_element.base_element.kernel, 'sigmoid') # test for other optimizers smac_config = {'SVC__C': 2, 'SVC__kernel': 'rbf'} self.estimator_switch.set_params(**smac_config) self.assertEqual(self.estimator_switch.base_element.base_element.C, 2) self.assertEqual( self.estimator_switch.base_element.base_element.kernel, 'rbf') def test_fit(self): np.random.seed(42) self.estimator_switch.set_params(**{'current_element': (1, 0)}) self.estimator_switch.fit(self.X, self.y) np.random.seed(42) self.tree.set_params(**{'min_samples_split': 2}) self.tree.fit(self.X, self.y) np.testing.assert_array_equal( self.tree.base_element.feature_importances_, self.estimator_switch.base_element.feature_importances_) def test_transform(self): self.transformer_switch_with_branch.set_params( **{'current_element': (0, 0)}) self.transformer_switch_with_branch.fit(self.X, self.y) self.pca.fit(self.X, self.y) switch_Xt, _, _ = self.transformer_switch_with_branch.transform(self.X) pca_Xt, _, _ = self.pca.transform(self.X) self.assertTrue(np.array_equal(pca_Xt, switch_Xt)) def test_predict(self): self.estimator_switch.set_params(**{'current_element': (1, 0)}) np.random.seed(42) self.estimator_switch.fit(self.X, self.y) self.tree.set_params(**{'min_samples_split': 2}) np.random.seed(42) self.tree.fit(self.X, self.y) switch_preds = self.estimator_switch.predict(self.X) tree_preds = self.tree.predict(self.X) self.assertTrue(np.array_equal(switch_preds, tree_preds)) def test_predict_proba(self): gpc = PipelineElement('GaussianProcessClassifier') svc = PipelineElement('SVC') switch = Switch('EstimatorSwitch', [gpc, svc]) switch.set_params(**{'current_element': (0, 0)}) np.random.seed(42) switch_probas = switch.fit(self.X, self.y).predict_proba(self.X) np.random.seed(42) gpr_probas = self.gpc.fit(self.X, self.y).predict_proba(self.X) self.assertTrue(np.array_equal(switch_probas, gpr_probas)) def test_inverse_transform(self): self.transformer_switch_with_branch.set_params( **{'current_element': (0, 0)}) self.transformer_switch_with_branch.fit(self.X, self.y) self.pca.fit(self.X, self.y) Xt_pca, _, _ = self.pca.transform(self.X) Xt_switch, _, _ = self.transformer_switch_with_branch.transform(self.X) X_pca, _, _ = self.pca.inverse_transform(Xt_pca) X_switch, _, _ = self.transformer_switch_with_branch.inverse_transform( Xt_switch) self.assertTrue(np.array_equal(Xt_pca, Xt_switch)) self.assertTrue(np.array_equal(X_pca, X_switch)) np.testing.assert_almost_equal(X_switch, self.X) def test_base_element(self): switch = Switch('switch', [self.svc, self.tree]) switch.set_params(**{'current_element': (1, 1)}) self.assertIs(switch.base_element, self.tree) self.assertIs(switch.base_element.base_element, self.tree.base_element) # other optimizer switch.set_params(**{'DecisionTreeClassifier__min_samples_split': 2}) self.assertIs(switch.base_element, self.tree) self.assertIs(switch.base_element.base_element, self.tree.base_element) def test_copy_me(self): switches = [ self.estimator_switch, self.estimator_switch_with_branch, self.transformer_switch_with_branch, self.switch_in_switch ] for switch in switches: copy = switch.copy_me() self.assertEqual(switch.random_state, copy.random_state) for i, element in enumerate(copy.elements): self.assertNotEqual(copy.elements[i], switch.elements[i]) switch = elements_to_dict(switch) copy = elements_to_dict(copy) self.assertDictEqual(copy, switch) def test_estimator_type(self): pca = PipelineElement('PCA') ica = PipelineElement('FastICA') svc = PipelineElement('SVC') svr = PipelineElement('SVR') tree_class = PipelineElement('DecisionTreeClassifier') tree_reg = PipelineElement('DecisionTreeRegressor') switch = Switch('MySwitch', [pca, svr]) with self.assertRaises(NotImplementedError): est_type = switch._estimator_type switch = Switch('MySwitch', [svc, svr]) with self.assertRaises(NotImplementedError): est_type = switch._estimator_type switch = Switch('MySwitch', [pca, ica]) self.assertEqual(switch._estimator_type, None) switch = Switch('MySwitch', [tree_class, svc]) self.assertEqual(switch._estimator_type, 'classifier') switch = Switch('MySwitch', [tree_reg, svr]) self.assertEqual(switch._estimator_type, 'regressor') self.assertEqual(self.estimator_switch._estimator_type, 'classifier') self.assertEqual(self.estimator_switch_with_branch._estimator_type, 'classifier') self.assertEqual(self.transformer_switch_with_branch._estimator_type, None) self.assertEqual(self.switch_in_switch._estimator_type, None) def test_add(self): self.assertEqual(len(self.estimator_switch.elements), 3) self.assertEqual(len(self.switch_in_switch.elements), 2) self.assertEqual(len(self.transformer_switch_with_branch.elements), 2) self.assertEqual( list(self.estimator_switch.elements_dict.keys()), ['SVC', 'DecisionTreeClassifier', 'GaussianProcessClassifier']) self.assertEqual( list(self.switch_in_switch.elements_dict.keys()), ['transformer_branch', 'transformer_switch_with_branch']) switch = Switch('MySwitch', [PipelineElement('PCA'), PipelineElement('FastICA')]) switch = Switch('MySwitch2') switch += PipelineElement('PCA') switch += PipelineElement('FastICA') # test doubled names with self.assertRaises(ValueError): self.estimator_switch += self.estimator_switch.elements[0] self.estimator_switch += PipelineElement("SVC") self.assertEqual(self.estimator_switch.elements[-1].name, "SVC2") self.estimator_switch += PipelineElement( "SVC", hyperparameters={'kernel': ['polynomial', 'sigmoid']}) self.assertEqual(self.estimator_switch.elements[-1].name, "SVC3") self.estimator_switch += PipelineElement("SVR") self.assertEqual(self.estimator_switch.elements[-1].name, "SVR") self.estimator_switch += PipelineElement("SVC") self.assertEqual(self.estimator_switch.elements[-1].name, "SVC4") # check that hyperparameters are renamed respectively self.assertEqual( self.estimator_switch.pipeline_element_configurations[4][0] ["SVC3__kernel"], 'polynomial') def test_feature_importances(self): self.estimator_switch.set_params(**{'current_element': (1, 0)}) self.estimator_switch.fit(self.X, self.y) self.assertTrue( len(self.estimator_switch.feature_importances_) == self.X.shape[1]) self.estimator_switch_with_branch.set_params( **{'current_element': (1, 0)}) self.estimator_switch_with_branch.fit(self.X, self.y) self.assertTrue( len(self.estimator_switch_with_branch.feature_importances_) == self.X.shape[1]) self.estimator_switch.set_params(**{'current_element': (2, 0)}) self.estimator_switch.fit(self.X, self.y) self.assertIsNone(self.estimator_branch.feature_importances_) self.switch_in_switch.set_params(**{'current_element': (1, 0)}) self.switch_in_switch.fit(self.X, self.y) self.assertIsNone(self.switch_in_switch.feature_importances_) self.estimator_switch.set_params(**{'current_element': (1, 0)}) self.switch_in_switch.fit(self.X, self.y) self.assertIsNone(self.switch_in_switch.feature_importances_)
optimizer='smac', # which optimizer PHOTON shall use, in this case smac optimizer_params={'scenario_dict': scenario_dict}, metrics=['mean_squared_error', 'pearson_correlation'], best_config_metric='mean_squared_error', outer_cv=ShuffleSplit(n_splits=1, test_size=0.2), inner_cv=KFold(n_splits=3), verbosity=1, output_settings=settings) # ADD ELEMENTS TO YOUR PIPELINE # first normalize all features my_pipe.add(PipelineElement('StandardScaler')) # then do feature selection using a PCA, specify which values to try in the hyperparameter search my_pipe += PipelineElement('PCA', hyperparameters={'n_components': IntegerRange(5, 10)}, test_disabled=True) switch = Switch("Test_Switch") # engage and optimize SVR # linspace and logspace is converted to uniform and log-uniform priors in skopt switch += PipelineElement('SVR', hyperparameters={'C': FloatRange(0, 10, range_type='linspace'), 'epsilon': FloatRange(0, 0.0001, range_type='linspace'), 'tol': FloatRange(1e-4, 1e-2, range_type='linspace'), 'kernel': Categorical(['linear', 'rbf', 'poly'])}) switch += PipelineElement('RandomForestRegressor', hyperparameters={'n_estimators': Categorical([10, 20])}) my_pipe += switch # NOW TRAIN YOUR PIPELINE my_pipe.fit(X, y)