def predict_proba_instance(self, query):
"""Predicts the posterior probabilities of the corresponding query sample.
If self.mode == "all", get the probability estimates of the selected ensemble. Otherwise,
the technique gets the probability estimates from the selected base classifier
Parameters
----------
query : array containing the test sample = [n_features]
Returns
-------
predicted_proba : array = [n_classes] with the probability estimates for all classes
"""
competences = self.estimate_competence(query)
if self.selection_method != 'all':
# only one classifier is selected
clf_index = self.select(competences)
predicted_proba = self.pool_classifiers[clf_index].predict_proba(
query)
else:
# Selected ensemble of classifiers is combined using Majority Voting
indices = self.select(competences)
classifier_ensemble = self._get_classifier_ensemble(indices)
predicted_proba = predict_proba_ensemble(classifier_ensemble,
query)
return predicted_proba
def predict_proba(self, X):
"""Estimates the posterior probabilities for sample in X.
Parameters
----------
X : array of shape (n_samples, n_features)
The input data.
Returns
-------
predicted_proba : array of shape (n_samples, n_classes)
Probabilities estimates for each sample in X.
"""
self._check_is_fitted()
X = check_array(X)
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} and "
"input n_features is {1}."
"".format(self.n_features_, X.shape[1]))
self._check_predict_proba()
features = self.estimator_features_[self.clf_indices_]
proba = predict_proba_ensemble(self.ensemble_, X, features)
return proba
def predict_proba(self, X):
"""Estimates the posterior probabilities for sample in X.
Parameters
----------
X : array of shape = [n_samples, n_features]
The input data.
Returns
-------
predicted_proba : array of shape = [n_samples, n_classes] with the
probabilities estimates for each class in the classifier model.
"""
# Check if the DS model was trained
self._check_is_fitted()
# Check if X is a valid input
self._check_input_predict(X)
n_samples = X.shape[0]
predicted_proba = np.zeros((n_samples, self.n_classes))
for index, instance in enumerate(X):
# Do not use dynamic selection if all base classifiers agrees on the
# same label.
instance = instance.reshape(1, -1)
if self._all_classifier_agree(instance):
# since it may have better probabilities estimates
predicted_proba[index, :] = predict_proba_ensemble(self.pool_classifiers, instance)[0]
else:
# Check whether use the DFP or hardness information is used to compute the competence region
if self.DFP or self.with_IH:
self.distances, self.neighbors = self._get_region_competence(instance)
# If Instance hardness (IH) is used, check the hardness level of the region of competence
# to decide between DS or the roc_algorithm classifier
if self.with_IH and (self._hardness_region_competence(self.neighbors) <= self.IH_rate):
# use the KNN for prediction if the sample is located in a safe region.
# TODO: Optimize that to not re-calculate the neighborhood
predicted_proba[index, :] = self.roc_algorithm.predict_proba(instance)
# Otherwise, use DS for classification
else:
# Check if the dynamic frienemy pruning should be used
if self.DFP:
self.DFP_mask = self._frienemy_pruning()
else:
self.DFP_mask = np.ones(self.n_classifiers)
predicted_proba[index, :] = self.predict_proba_instance(instance)
# Reset the neighbors and the distances as they are specific to a given query.
self.neighbors = None
self.distances = None
return predicted_proba
def predict_proba(self, X):
"""Estimates the posterior probabilities for sample in X.
Parameters
----------
X : array of shape = [n_samples, n_features]
The input data.
Returns
-------
predicted_proba : array of shape = [n_samples, n_classes]
Probabilities estimates for each sample in X.
"""
self._check_is_fitted()
self._check_predict_proba()
proba = predict_proba_ensemble(self.ensemble_, X)
return proba
def predict_proba_instance(self, query):
"""Predicts the posterior probabilities of the corresponding query sample.
If self.mode == "selection", the selected ensemble is used to estimate the probabilities. The average rule is
used to give probabilities estimates.
If self.mode == "weighting", all base classifiers are used for estimating the probabilities, however their
influence in the final decision are weighted according to their estimated competence level. A weighted average
method is used to give the probabilities estimates.
If self.mode == "Hybrid", A hybrid Dynamic selection and weighting approach is used. First an
ensemble with the competent base classifiers are selected. Then, their decisions are aggregated using a
weighted average rule to give the probabilities estimates.
Parameters
----------
query : array of shape = [n_features]
The test sample
Returns
-------
predicted_proba : array = [n_classes] with the probability estimates for all classes
"""
competences = self.estimate_competence(query)
if self.mode == "selection":
indices = self.select(competences)
classifier_ensemble = self._get_classifier_ensemble(indices)
predicted_proba = predict_proba_ensemble(classifier_ensemble,
query)
elif self.mode == "weighting":
predicted_proba = predict_proba_ensemble_weighted(
self.pool_classifiers, competences, query)
else:
indices = self.select(competences)
competences_ensemble = competences[indices]
classifier_ensemble = self._get_classifier_ensemble(indices)
predicted_proba = predict_proba_ensemble_weighted(
classifier_ensemble, competences_ensemble, query)
return predicted_proba
def test_predict_proba():
query = np.array([[1, -1]])
ensemble_classifiers = create_pool_classifiers()
predicted_proba = predict_proba_ensemble(ensemble_classifiers, query)
assert np.isclose(predicted_proba, [0.61, 0.39]).all()