def classify_instance(self, query, predictions):
"""Predicts the class label of the corresponding query sample.
If self.mode == "all", the majority voting scheme is used to aggregate the predictions of all classifiers with
the max competence level estimate.
Parameters
----------
query : array containing the test sample = [n_samples, n_features]
predictions : array of shape = [n_samples, n_classifiers]
Contains the predictions of all base classifier for all samples in the query array
Returns
-------
The predicted label of the query
"""
competences = self.estimate_competence(query, predictions=predictions)
if self.selection_method != 'all':
# only one classifier is selected
clf_index = self.select(competences)
predicted_label = predictions[clf_index]
else:
# Selected ensemble of classifiers is combined using Majority Voting
indices = self.select(competences)
votes = np.atleast_2d(predictions[indices])
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_with_ds(self, query, predictions, probabilities=None):
"""Predicts the label of the corresponding query sample.
Parameters
----------
query : array of shape = [n_features]
The test sample.
predictions : array of shape = [n_samples, n_classifiers]
Predictions of the base classifiers for all test examples.
probabilities : array of shape = [n_samples, n_classifiers, n_classes]
Probabilities estimates of each base classifier for all test examples.
Returns
-------
predicted_label : array of shape = [n_samples]
Predicted class label for each test example.
"""
if query.ndim < 2:
query = query.reshape(1, -1)
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
if query.shape[0] != predictions.shape[0]:
raise ValueError('The arrays query and predictions must have the same number of samples. query.shape is {}'
'and predictions.shape is {}' .format(query.shape, predictions.shape))
selected_classifiers = self.select(query)
votes = predictions[np.arange(predictions.shape[0])[:, None], selected_classifiers]
predicted_label = majority_voting_rule(votes)
return predicted_label
def predict(self, X):
"""Predict the label of each sample in X and returns the predicted
label.
Parameters
----------
X : array of shape (n_samples, n_features)
The data to be classified
Returns
-------
predicted_labels : array of shape (n_samples)
Predicted class 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]))
votes = np.zeros((X.shape[0], self.n_classifiers_ensemble_))
for idx, clf in enumerate(self.ensemble_):
X_space = X[:, self.estimator_features_[self.clf_indices_[idx]]]
votes[:, idx] = self._encode_base_labels(clf.predict(X_space))
predicted_labels = majority_voting_rule(votes).astype(int)
return self.classes_.take(predicted_labels)
def classify_with_ds(self,
predictions,
probabilities=None,
neighbors=None,
distances=None,
DFP_mask=None):
"""Predicts the class label of the corresponding query sample.
If self.selection_method == "all", the majority voting scheme is used
to aggregate the predictions of all classifiers with the max competence
level estimates for each test examples.
Parameters
----------
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifiers for all test examples
probabilities : array of shape (n_samples, n_classifiers, n_classes)
Probabilities estimates of each base classifier for all test
examples (For methods that always require probabilities from the
base classifiers)
neighbors : array of shape (n_samples, n_neighbors)
Indices of the k nearest neighbors.
distances : array of shape (n_samples, n_neighbors)
Distances from the k nearest neighbors to the query
DFP_mask : array of shape (n_samples, n_classifiers)
Mask containing 1 for the selected base classifier and 0 otherwise.
Returns
-------
predicted_label : array of shape (n_samples)
The predicted label for each query
"""
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
competences = self.estimate_competence(neighbors,
distances=distances,
predictions=predictions)
if self.DFP:
competences = competences * DFP_mask
if self.selection_method != 'all':
# only one classifier is selected
clf_index = self.select(competences)
predicted_label = predictions[np.arange(predictions.shape[0]),
clf_index]
else:
# Selected ensemble of classifiers is combined using Majority
# Voting
indices = self.select(competences)
votes = np.ma.MaskedArray(predictions, ~indices)
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_with_ds(self,
query,
predictions,
probabilities=None,
neighbors=None,
distances=None,
DFP_mask=None):
"""Predicts the label of the corresponding query sample.
Parameters
----------
query : array of shape = [n_features]
The test sample.
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifiers for all test examples.
probabilities : array of shape (n_samples, n_classifiers, n_classes)
Probabilities estimates of each base classifier for all test
examples.
neighbors : array of shape (n_samples, n_neighbors)
Indices of the k nearest neighbors according for each test sample.
distances : array of shape (n_samples, n_neighbors)
Distances of the k nearest neighbors according for each test
sample.
DFP_mask : array of shape (n_samples, n_classifiers)
Mask containing 1 for the selected base classifier and 0 otherwise.
Returns
-------
predicted_label : array of shape (n_samples)
Predicted class label for each test example.
"""
if query.ndim < 2:
query = query.reshape(1, -1)
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
if query.shape[0] != predictions.shape[0]:
raise ValueError(
'The arrays query and predictions must have the same number'
' of samples. query.shape is {}'
'and predictions.shape is {}'.format(query.shape,
predictions.shape))
selected_classifiers = self.select(query)
votes = predictions[np.arange(predictions.shape[0])[:, None],
selected_classifiers]
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_with_ds(self, query, predictions, probabilities=None, neighbors=None, distances=None, DFP_mask=None):
"""Predicts the label of the corresponding query sample.
Parameters
----------
query : array of shape = [n_samples, n_features]
The test examples
predictions : array of shape = [n_samples, n_classifiers]
Predictions of the base classifiers for all test examples
probabilities : array of shape = [n_samples, n_classifiers, n_classes]
Probabilities estimates of each base classifier for all test examples.
neighbors : array of shale = [n_samples, n_neighbors]
Indices of the k nearest neighbors according for each test sample
distances : array of shale = [n_samples, n_neighbors]
Distances of the k nearest neighbors according for each test sample
DFP_mask : array of shape = [n_samples, n_classifiers]
Mask containing 1 for the selected base classifier and 0 otherwise.
Notes
------
Different than other DES techniques, this method only select N candidates from the pool of classifiers.
Returns
-------
predicted_label : array of shape = [n_samples]
Predicted class label for each test example.
"""
if query.ndim < 2:
query = query.reshape(1, -1)
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
if query.shape[0] != predictions.shape[0]:
raise ValueError('The arrays query and predictions must have the same number of samples. query.shape is {}'
'and predictions.shape is {}' .format(query.shape, predictions.shape))
accuracy = self.estimate_competence(query,
neighbors=neighbors,
predictions=predictions)
if self.DFP:
accuracy = accuracy * DFP_mask
selected_classifiers = self.select(accuracy)
votes = predictions[np.arange(predictions.shape[0])[:, None], selected_classifiers]
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_with_ds(self, query, predictions, probabilities=None):
"""Predicts the class label of the corresponding query sample.
If self.selection_method == "all", the majority voting scheme is used to aggregate the predictions
of all classifiers with the max competence level estimates for each test examples.
Parameters
----------
query : array of shape = [n_samples, n_features]
The test examples.
predictions : array of shape = [n_samples, n_classifiers]
Predictions of the base classifiers for all test examples.
probabilities : array of shape = [n_samples, n_classifiers, n_classes]
Probabilities estimates of each base classifier for all test examples. (For methods that
always require probabilities from the base classifiers).
Returns
-------
predicted_label : array of shape = [n_samples]
Predicted class label for each test example.
"""
if query.ndim < 2:
query = query.reshape(1, -1)
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
if query.shape[0] != predictions.shape[0]:
raise ValueError(
'The arrays query and predictions must have the same shape. query.shape is {}'
'and predictions.shape is {}'.format(query.shape,
predictions.shape))
competences = self.estimate_competence(query, predictions=predictions)
if self.selection_method != 'all':
# only one classifier is selected
clf_index = self.select(competences)
predicted_label = predictions[np.arange(predictions.shape[0]),
clf_index]
else:
# Selected ensemble of classifiers is combined using Majority Voting
indices = self.select(competences)
votes = np.ma.MaskedArray(predictions, ~indices)
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_with_ds(self, query, predictions, probabilities=None):
"""Predicts the label of the corresponding query sample.
Parameters
----------
query : array of shape = [n_samples, n_features]
The test examples
predictions : array of shape = [n_samples, n_classifiers]
Predictions of the base classifiers for all test examples
probabilities : array of shape = [n_samples, n_classifiers, n_classes]
Probabilities estimates of each base classifier for all test examples.
Notes
------
Different than other DES techniques, this method is based on a two stage selection, where
first the most accurate classifier are selected, then the diversity information is used to get the most
diverse ensemble for the probability estimation. Hence, the weighting mode is not defined. Also, the
selected ensemble size is fixed (self.J), so there is no need to use masked arrays in this class.
Returns
-------
predicted_label : array of shape = [n_samples]
Predicted class label for each test example.
"""
if query.ndim < 2:
query = query.reshape(1, -1)
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
if query.shape[0] != predictions.shape[0]:
raise ValueError('The arrays query and predictions must have the same number of samples. query.shape is {}'
'and predictions.shape is {}' .format(query.shape, predictions.shape))
accuracy, diversity = self.estimate_competence(query, predictions)
if self.DFP:
accuracy = accuracy * self.DFP_mask
selected_classifiers = self.select(accuracy, diversity)
votes = predictions[np.arange(predictions.shape[0])[:, None], selected_classifiers]
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_instance(self, query, predictions):
"""Predicts the label of the corresponding query sample.
Returns the predicted label.
Parameters
----------
query : array of shape = [n_features]
The test sample
predictions : array of shape = [n_samples, n_classifiers]
Contains the predictions of all base classifier for all samples in the query array
Returns
-------
predicted_label: The predicted label of the query
"""
indices = self.select(query)
votes = np.atleast_2d(predictions[indices])
predicted_label = majority_voting_rule(votes)
return predicted_label
def classify_instance(self, query, predictions):
"""Predicts the label of the corresponding query sample.
If self.mode == "selection", the selected ensemble is combined using the
majority voting rule
If self.mode == "weighting", all base classifiers are used for classification, however their influence
in the final decision are weighted according to their estimated competence level. The weighted majority voting
scheme is used to combine the decisions of the base classifiers.
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 the
weighted majority voting rule according to its competence level estimates.
Parameters
----------
query : array containing the test sample = [n_samples, n_features]
predictions : array of shape = [n_samples, n_classifiers]
Contains the predictions of all base classifier for all samples in the query array
Returns
-------
predicted_label: The predicted label of the query
"""
competences = self.estimate_competence(query)
if self.mode == "selection":
indices = self.select(competences)
votes = np.atleast_2d(predictions[indices])
predicted_label = majority_voting_rule(votes)
elif self.mode == "weighting":
votes = np.atleast_2d(predictions)
predicted_label = weighted_majority_voting_rule(votes, competences)
else:
indices = self.select(competences)
competences_ensemble = competences[indices]
votes = np.atleast_2d(predictions[indices])
predicted_label = weighted_majority_voting_rule(votes, competences_ensemble)
return predicted_label
def predict(self, X):
"""Predict the label of each sample in X and returns the predicted
label.
Parameters
----------
X : array of shape = [n_samples, n_features]
The data to be classified
Returns
-------
predicted_labels : array of shape = [n_samples]
Predicted class for each sample in X.
"""
X = check_array(X)
self._check_is_fitted()
votes = np.zeros((X.shape[0], self.n_classifiers_ensemble_))
for clf_index, clf in enumerate(self.ensemble_):
votes[:, clf_index] = self._encode_base_labels(clf.predict(X))
predicted_labels = majority_voting_rule(votes).astype(int)
return self.classes_.take(predicted_labels)
def classify_with_ds(self,
query,
predictions,
probabilities=None,
neighbors=None,
distances=None,
DFP_mask=None):
"""Predicts the label of the corresponding query sample.
If self.mode == "selection", the selected ensemble is combined using
the majority voting rule
If self.mode == "weighting", all base classifiers are used for
classification, however their influence in the final decision are
weighted according to their estimated competence level. The weighted
majority voting scheme is used to combine the decisions of the
base classifiers.
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 the weighted
majority voting rule according to its competence level estimates.
Parameters
----------
query : array of shape (n_samples, n_features)
The test examples.
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifier for all test examples.
probabilities : array of shape (n_samples, n_classifiers, n_classes)
Probabilities estimates of each base classifier for all test
examples. (For methods that always require probabilities from
the base classifiers).
neighbors : array of shape (n_samples, n_neighbors)
Indices of the k nearest neighbors according for each test sample.
distances : array of shape (n_samples, n_neighbors)
Distances of the k nearest neighbors according for each test
sample.
DFP_mask : array of shape (n_samples, n_classifiers)
Mask containing 1 for the selected base classifier and 0 otherwise.
Returns
-------
predicted_label : array of shape (n_samples)
Predicted class label for each test example.
"""
if query.ndim < 2:
query = query.reshape(1, -1)
if predictions.ndim < 2:
predictions = predictions.reshape(1, -1)
if query.shape[0] != predictions.shape[0]:
raise ValueError(
'The arrays query and predictions must have the same number'
' of samples. query.shape is {}'
'and predictions.shape is {}'.format(query.shape,
predictions.shape))
if self.needs_proba:
competences = self.estimate_competence_from_proba(
query,
neighbors=neighbors,
distances=distances,
probabilities=probabilities)
else:
competences = self.estimate_competence(query,
neighbors=neighbors,
distances=distances,
predictions=predictions)
if self.DFP:
competences = competences * DFP_mask
if self.mode == "selection":
# The selected_classifiers matrix is used as a mask to remove
# the predictions of certain base classifiers.
selected_classifiers = self.select(competences)
votes = np.ma.MaskedArray(predictions, ~selected_classifiers)
predicted_label = majority_voting_rule(votes)
elif self.mode == "weighting":
votes = np.atleast_2d(predictions)
predicted_label = weighted_majority_voting_rule(
votes, competences, np.arange(self.n_classes_))
else:
selected_classifiers = self.select(competences)
votes = np.ma.MaskedArray(predictions, ~selected_classifiers)
predicted_label = weighted_majority_voting_rule(
votes, competences, np.arange(self.n_classes_))
return predicted_label
