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)