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 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.
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.
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 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.
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
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 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,
neighbors,
distances=distances,
predictions=predictions)
if self.DFP:
accuracy = accuracy * 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_with_ds(self, query, 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
----------
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)
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.
Returns
-------
predicted_label : array of shape = [n_samples]
The predicted label for each query
"""
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, 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