def predict(self, X):
"""Hard decision."""
# print("PREDICT")
# Check is fit had been called
check_is_fitted(self, "classes_")
# Input validation
X = check_array(X)
if X.shape[1] != self.X_.shape[1]:
raise ValueError("number of features does not match")
X_dsel = self.previous_X
y_dsel = self.previous_y
if self.oversampled:
ros = RandomOverSampler(random_state=42)
X_dsel, y_dsel = ros.fit_resample(X_dsel, y_dsel)
if self.desMethod == "KNORAE":
des = KNORAE(self.ensemble_, random_state=42)
elif self.desMethod == "KNORAU":
des = KNORAU(self.ensemble_, random_state=42)
elif self.desMethod == "LCA":
des = LCA(self.ensemble_, random_state=42)
elif self.desMethod == "Rank":
des = Rank(self.ensemble_, random_state=42)
else:
des = KNORAE(self.ensemble_, random_state=42)
des.fit(X_dsel, y_dsel)
prediction = des.predict(X)
return prediction
def _create_hard_estimator(self, k):
clf = None
if self.selection_method == 'ola':
clf = OLA(self.pool_classifiers, DFP=self.dfp, k=k)
elif self.selection_method == 'lca':
clf = LCA(self.pool_classifiers, DFP=self.dfp, k=k)
else:
raise ValueError("The chosen selection method is not available")
return clf
def initialize_ds(pool_classifiers, X, y, k=5):
knorau = KNORAU(pool_classifiers, k=k)
kne = KNORAE(pool_classifiers, k=k)
desknn = DESKNN(pool_classifiers, k=k)
ola = OLA(pool_classifiers, k=k)
lca = LCA(pool_classifiers, k=k)
mla = MLA(pool_classifiers, k=k)
mcb = MCB(pool_classifiers, k=k)
rank = Rank(pool_classifiers, k=k)
knop = KNOP(pool_classifiers, k=k)
meta = METADES(pool_classifiers, k=k)
list_ds = [knorau, kne, ola, lca, mla, desknn, mcb, rank, knop, meta]
names = [
'KNORA-U', 'KNORA-E', 'OLA', 'LCA', 'MLA', 'DESKNN', 'MCB', 'RANK',
'KNOP', 'META-DES'
]
# fit the ds techniques
for ds in list_ds:
ds.fit(X, y)
return list_ds, names
def test_lca(knn_methods):
pool_classifiers, X_dsel, y_dsel, X_test, y_test = setup_classifiers()
lca = LCA(pool_classifiers, knn_classifier=knn_methods)
lca.fit(X_dsel, y_dsel)
assert np.isclose(lca.score(X_test, y_test), 0.973404255319149)
# Normalizing the dataset to have 0 mean and unit variance.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
pool_classifiers = BaggingClassifier(Perceptron(max_iter=100),
random_state=rng)
pool_classifiers.fit(X_train, y_train)
# Setting with_IH
mcb = MCB(pool_classifiers)
ola = OLA(pool_classifiers)
des_p = DESP(pool_classifiers)
knu = KNORAU(pool_classifiers)
lca = LCA(pool_classifiers)
kne = KNORAE(pool_classifiers)
rank = Rank(pool_classifiers)
list_ds_methods = [mcb, ola, des_p, knu, lca, kne, rank]
names = ['MCB', 'OLA', 'DES-P', 'KNORA-U', 'LCA', 'KNORA-E', 'Rank']
k_value_list = range(3, 16)
###############################################################################
# Plot accuracy x region of competence size.
# -------------------------------------------
# We can see the this parameter can have a huge influence in the performance
# of certain DS techniques. The main exception being the KNORA-E and Rank
# which have built-in mechanism to automatically adjust the region
# of competence size during the competence level estimation.
y_train,
test_size=0.5,
random_state=rng)
# Considering a pool composed of 10 base classifiers
pool_classifiers = RandomForestClassifier(n_estimators=10,
random_state=rng,
max_depth=10)
pool_classifiers.fit(X_train, y_train)
ds_names = ['A Priori', 'A Posteriori', 'OLA', 'LCA', 'DES-P', 'META-DES']
# DS techniques without DFP
apriori = APriori(pool_classifiers, random_state=rng)
aposteriori = APosteriori(pool_classifiers, random_state=rng)
ola = OLA(pool_classifiers)
lca = LCA(pool_classifiers)
desp = DESP(pool_classifiers)
meta = METADES(pool_classifiers)
# FIRE-DS techniques (with DFP)
fire_apriori = APriori(pool_classifiers, DFP=True, random_state=rng)
fire_aposteriori = APosteriori(pool_classifiers, DFP=True, random_state=rng)
fire_ola = OLA(pool_classifiers, DFP=True)
fire_lca = LCA(pool_classifiers, DFP=True)
fire_desp = DESP(pool_classifiers, DFP=True)
fire_meta = METADES(pool_classifiers, DFP=True)
list_ds = [apriori, aposteriori, ola, lca, desp, meta]
list_fire_ds = [
fire_apriori, fire_aposteriori, fire_ola, fire_lca, fire_desp, fire_meta
]
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 (7 neighbors)
knorau = KNORAU(pool_classifiers, random_state=rng)
kne = KNORAE(pool_classifiers, random_state=rng)
ola = OLA(pool_classifiers, random_state=rng)
lca = LCA(pool_classifiers, random_state=rng)
mcb = MCB(pool_classifiers, random_state=rng)
meta = METADES(pool_classifiers, random_state=rng)
names = ['Single Best', 'Static Selection', 'Stacked',
'KNORA-U', 'KNORA-E', 'OLA', 'LCA','MCB', 'META-DES']
methods = [single_best, static_selection, stacked,
knorau, kne, ola, lca, mcb, meta]
# Fit the DS techniques
scores = []
for method, name in zip(methods, names):
method.fit(X_dsel, y_dsel)
scores.append(method.score(X_test, y_test))
print("Classification accuracy {} = {}"