def test_stacking_pre_estimator_mitigation_final_only(self): model = StackingClassifier( estimators=[ ("dtc", DecisionTreeClassifier()), ("lr", LogisticRegression()), ], final_estimator=DisparateImpactRemover(**self.fairness_info) >> DecisionTreeClassifier(), passthrough=True, ) self._attempt_fit_predict(model)
def test_stacking_post_estimator_mitigation_final_only(self): model = StackingClassifier( estimators=[ ("dtc", DecisionTreeClassifier()), ("lr", LogisticRegression()), ], final_estimator=CalibratedEqOddsPostprocessing( **self.fairness_info, estimator=DecisionTreeClassifier()), passthrough=True, ) self._attempt_fit_predict(model)
def test_bagging_post_estimator_mitigation_base(self): model = BaggingClassifier( base_estimator=CalibratedEqOddsPostprocessing( **self.fairness_info, estimator=DecisionTreeClassifier() ) ) self._attempt_fit_predict(model)
def test_estimators(self): trainable = VotingClassifier(estimators=[( 'lr', LogisticRegression()), ('dt', DecisionTreeClassifier()), ('na', None)]) trained = trainable.fit(self.train_X, self.train_y) predicted = trained.predict(self.test_X)
def test_shallow_planned_nested_list_indiv_operator(self): from lale.lib.sklearn import DecisionTreeClassifier, VotingClassifier clf = VotingClassifier(estimators=[("dtc", DecisionTreeClassifier())]) params = clf.get_params(deep=False) filtered_params = self.remove_lale_params(params) filtered_params["voting"] == "hard"
def test_ada_boost1(self): from sklearn.tree import DecisionTreeClassifier from lale.lib.sklearn import AdaBoostClassifier clf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier()) clf.fit(self.X_train, self.y_train)
def test_shallow_planned_nested_indiv_operator(self): from lale.lib.sklearn import BaggingClassifier, DecisionTreeClassifier clf = BaggingClassifier(base_estimator=DecisionTreeClassifier()) params = clf.get_params(deep=False) filtered_params = self.remove_lale_params(params) assert filtered_params["bootstrap"]
def test_with_defaults(self): trainable = VotingClassifier( estimators=[("lr", LogisticRegression()), ("dt", DecisionTreeClassifier())]) trained = trainable.fit(self.train_X, self.train_y) _ = trained.predict(self.test_X)
def test_estimators(self): trainable = VotingClassifier(estimators=[ ("lr", LogisticRegression()), ("dt", DecisionTreeClassifier()), ("na", None), ]) trained = trainable.fit(self.train_X, self.train_y) predicted = trained.predict(self.test_X)
def test_stacking_post_estimator_mitigation_ensemble(self): model = CalibratedEqOddsPostprocessing( **self.fairness_info, estimator=StackingClassifier(estimators=[ ("dtc", DecisionTreeClassifier()), ("lr", LogisticRegression()), ])) self._attempt_fit_predict(model)
def test_stacking_pre_estimator_mitigation_base_only(self): model = StackingClassifier(estimators=[ ( "dir+dtc", DisparateImpactRemover( **self.fairness_info) >> DecisionTreeClassifier(), ), ("lr", LogisticRegression()), ]) self._attempt_fit_predict(model)
def test_voting_post_estimator_mitigation_base(self): model = VotingClassifier(estimators=[ ( "dtc+ceop", CalibratedEqOddsPostprocessing( **self.fairness_info, estimator=DecisionTreeClassifier()), ), ("lr", LogisticRegression()), ]) self._attempt_fit_predict(model)
def test_ada_boost(self): from lale.lib.sklearn import AdaBoostClassifier, DecisionTreeClassifier clf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier()) trained = clf.auto_configure( self.X_train, self.y_train, optimizer=Hyperopt, max_evals=1 ) # Checking that the inner decision tree does not get the default value for min_samples_leaf, not sure if this will always pass self.assertNotEqual( trained.hyperparams()["base_estimator"].hyperparams()["min_samples_leaf"], 1 )
def test_hyperparam_estimator_list(self): lr = LogisticRegression() linear_reg = LinearRegression() dtc = DecisionTreeClassifier() cls_list = [("lr", lr), ("linear_reg", linear_reg)] vc = VotingClassifier(estimators=cls_list) replaced_vc = vc.replace(linear_reg, dtc) new_cls_list = [("lr", lr), ("linear_reg", dtc)] expected_vc = VotingClassifier(estimators=new_cls_list) self.assertEqual(replaced_vc.to_json(), expected_vc.to_json()) sc = StackingClassifier(estimators=cls_list, final_estimator=vc) replaced_sc = sc.replace(linear_reg, dtc) new_cls_list = [("lr", lr), ("linear_reg", dtc)] expected_sc = StackingClassifier( estimators=new_cls_list, final_estimator=expected_vc ) self.assertEqual(replaced_sc.to_json(), expected_sc.to_json())
def test_deep_planned_nested_indiv_operator(self): from lale.lib.sklearn import BaggingClassifier, DecisionTreeClassifier dtc = DecisionTreeClassifier() clf = BaggingClassifier(base_estimator=dtc) params = clf.get_params(deep=True) filtered_params = self.remove_lale_params(params) # expected = LogisticRegression.get_defaults() base = filtered_params["base_estimator"] base_params = self.remove_lale_params(base.get_params(deep=True)) nested_base_params = nest_HPparams("base_estimator", base_params) self.assertDictEqual( { k: v for k, v in filtered_params.items() if k.startswith("base_estimator__") and not k.startswith("base_estimator___lale") }, nested_base_params, )
def test_deep_grammar(self): from lale.grammar import Grammar from lale.lib.sklearn import BaggingClassifier, DecisionTreeClassifier from lale.lib.sklearn import KNeighborsClassifier as KNN from lale.lib.sklearn import LogisticRegression as LR from lale.lib.sklearn import StandardScaler as Scaler dtc = DecisionTreeClassifier() clf = BaggingClassifier(base_estimator=dtc) params = clf.get_params(deep=True) filtered_params = self.remove_lale_params(params) g = Grammar() g.start = g.estimator g.estimator = (NoOp | g.transformer) >> g.prim_est g.transformer = (NoOp | g.transformer) >> g.prim_tfm g.prim_est = LR | KNN g.prim_tfm = PCA | Scaler params = g.get_params(deep=True) filtered_params = self.remove_lale_params(params) assert filtered_params["start__name"] == "estimator" assert filtered_params["prim_est__LogisticRegression__penalty"] == "l2"
def test_ccp_alpha(self): trainable = DecisionTreeClassifier(ccp_alpha=0.01) trained = trainable.fit(self.train_X, self.train_y) predicted = trained.predict(self.test_X)
def test_adaboost_pre_estimator_mitigation_base(self): model = AdaBoostClassifier(base_estimator=DisparateImpactRemover( **self.fairness_info) >> DecisionTreeClassifier()) self._attempt_fit_predict(model)
def test_stacking_pre_estimator_mitigation_ensemble(self): model = DisparateImpactRemover( **self.fairness_info) >> StackingClassifier(estimators=[( "dtc", DecisionTreeClassifier()), ("lr", LogisticRegression())]) self._attempt_fit_predict(model)
def test_with_defaults(self): trainable = DecisionTreeClassifier() trained = trainable.fit(self.train_X, self.train_y) _ = trained.predict(self.test_X)
def test_bagging_pre_estimator_mitigation_ensemble(self): model = DisparateImpactRemover( **self.fairness_info) >> BaggingClassifier( base_estimator=DecisionTreeClassifier()) self._attempt_fit_predict(model)
def test_ccp_alpha(self): with self.assertRaisesRegex(jsonschema.ValidationError, "argument 'ccp_alpha' was unexpected"): _ = DecisionTreeClassifier(ccp_alpha=0.01)
def test_adaboost_post_estimator_mitigation_ensemble(self): model = CalibratedEqOddsPostprocessing( **self.fairness_info, estimator=AdaBoostClassifier( base_estimator=DecisionTreeClassifier())) self._attempt_fit_predict(model)