def test_stacked_subspaces():
rng = np.random.RandomState(123456)
X_dsel, X_test, X_train, y_dsel, y_test, y_train = load_dataset(None, rng)
pool = BaggingClassifier(LogisticRegression(),
max_features=0.5,
random_state=rng).fit(X_train, y_train)
stacked = StackedClassifier(pool)
stacked.fit(X_dsel, y_dsel)
assert np.isclose(stacked.score(X_test, y_test), 0.973404255319149)
def test_stacked_subspaces_proba():
rng = np.random.RandomState(123456)
X_dsel, X_test, X_train, y_dsel, y_test, y_train = load_dataset(None, rng)
pool = BaggingClassifier(LogisticRegression(),
max_features=0.5,
random_state=rng).fit(X_train, y_train)
stacked = StackedClassifier(pool)
stacked.fit(X_dsel, y_dsel)
y_pred = stacked.predict_proba(X_test).argmax(axis=1)
assert np.isclose(accuracy_score(y_pred, y_test), 0.973404255319149)
###############################################################################
# Comparison to baselines
# -----------------------
#
# Let's now compare the results with four baselines: Support Vector Machine
# (SVM) with an RBF kernel; Multi-Layer Perceptron (MLP), Random Forest,
# Adaboost, and Stacking.
# Setting a baseline using standard classification methods
svm = SVC(gamma='scale', random_state=rng).fit(X_train, y_train)
mlp = MLPClassifier(max_iter=10000, random_state=rng).fit(X_train, y_train)
forest = RandomForestClassifier(n_estimators=10,
random_state=rng).fit(X_train, y_train)
boosting = AdaBoostClassifier(random_state=rng).fit(X_train, y_train)
stacked_lr = StackedClassifier(pool_classifiers=pool_classifiers,
random_state=rng)
stacked_lr.fit(X_train, y_train)
stacked_dt = StackedClassifier(pool_classifiers=pool_classifiers,
random_state=rng,
meta_classifier=DecisionTreeClassifier())
stacked_dt.fit(X_train, y_train)
###############################################################################
fig2, sub = plt.subplots(2, 3, figsize=(15, 7))
plt.subplots_adjust(wspace=0.4, hspace=0.4)
titles = [
'SVM decision', 'MLP decision', 'RF decision', 'Boosting decision',
'Stacked LR', 'Stacked Decision Tree'
]
# Initializing the techniques
knorau = KNORAU(pool_classifiers)
kne = KNORAE(pool_classifiers)
desp = DESP(pool_classifiers)
metades = METADES(pool_classifiers, mode='hybrid')
# DCS techniques
ola = OLA(pool_classifiers)
mcb = MCB(pool_classifiers)
##############################################################################
# Adding stacked classifier as baseline comparison. Stacked classifier can
# be found in the static module. In this experiment we consider two types
# of stacking: one using logistic regression as meta-classifier
# (default configuration) and the other using a Decision Tree.
stacked_lr = StackedClassifier(pool_classifiers, random_state=rng)
stacked_dt = StackedClassifier(pool_classifiers,
random_state=rng,
meta_classifier=DecisionTreeClassifier())
# Fitting the DS techniques
knorau.fit(X_dsel, y_dsel)
kne.fit(X_dsel, y_dsel)
desp.fit(X_dsel, y_dsel)
metades.fit(X_dsel, y_dsel)
ola.fit(X_dsel, y_dsel)
mcb.fit(X_dsel, y_dsel)
# Fitting the tacking models
stacked_lr.fit(X_dsel, y_dsel)
stacked_dt.fit(X_dsel, y_dsel)
y,
test_size=0.25,
random_state=rng)
X_train, X_dsel, y_train, y_dsel = train_test_split(X_train,
y_train,
test_size=0.50,
random_state=rng)
pool_classifiers = BaggingClassifier(base_estimator=DecisionTreeClassifier(),
n_estimators=100,
random_state=rng)
pool_classifiers.fit(X_train, y_train)
# Setting up static methods.
stacked = StackedClassifier(pool_classifiers)
static_selection = StaticSelection(pool_classifiers)
single_best = SingleBest(pool_classifiers)
# Initialize a DS technique. Here we specify the size of
# the region of competence (5 neighbors)
knorau = KNORAU(pool_classifiers, random_state=rng)
kne = KNORAE(pool_classifiers, random_state=rng)
desp = DESP(pool_classifiers, random_state=rng)
ola = OLA(pool_classifiers, random_state=rng)
mcb = MCB(pool_classifiers, random_state=rng)
knop = KNOP(pool_classifiers, random_state=rng)
meta = METADES(pool_classifiers, random_state=rng)
names = [
'Single Best', 'Static Selection', 'Stacked', 'KNORA-U', 'KNORA-E',