def test_check_class_labels(self):
for n_labels in range(1, 10):
for n_learners in range(1, 10):
labels = np.random.randint(10, size=n_labels)
different_labels = np.random.randint(10, 20, size=np.random.randint(1, 10))
learner_list_1 = [mock.MockClassifier(classes_=labels) for _ in range(n_learners)]
learner_list_2 = [mock.MockClassifier(classes_=different_labels) for _ in range(np.random.randint(1, 5))]
shuffled_learners = random.sample(learner_list_1 + learner_list_2, len(learner_list_1 + learner_list_2))
self.assertTrue(modAL.utils.validation.check_class_labels(*learner_list_1))
self.assertFalse(modAL.utils.validation.check_class_labels(*shuffled_learners))
def test_add_training_data(self):
for n_samples in range(1, 10):
for n_features in range(1, 10):
for n_new_samples in range(1, 10):
# testing for valid cases
# 1. integer class labels
X_initial = np.random.rand(n_samples, n_features)
y_initial = np.random.randint(0, 2, size=(n_samples, ))
X_new = np.random.rand(n_new_samples, n_features)
y_new = np.random.randint(0, 2, size=(n_new_samples, ))
learner = modAL.models.ActiveLearner(
estimator=mock.MockClassifier(),
X_training=X_initial,
y_training=y_initial)
learner._add_training_data(X_new, y_new)
np.testing.assert_almost_equal(
learner.X_training, np.vstack((X_initial, X_new)))
np.testing.assert_equal(learner.y_training,
np.concatenate((y_initial, y_new)))
# 2. vector class labels
y_initial = np.random.randint(0,
2,
size=(n_samples,
n_features + 1))
y_new = np.random.randint(0,
2,
size=(n_new_samples,
n_features + 1))
learner = modAL.models.ActiveLearner(
estimator=mock.MockClassifier(),
X_training=X_initial,
y_training=y_initial)
learner._add_training_data(X_new, y_new)
np.testing.assert_equal(learner.y_training,
np.concatenate((y_initial, y_new)))
# testing for invalid cases
# 1. len(X_new) != len(y_new)
X_new = np.random.rand(n_new_samples, n_features)
y_new = np.random.randint(0, 2, size=(2 * n_new_samples, ))
self.assertRaises(AssertionError,
learner._add_training_data, X_new, y_new)
# 2. X_new has wrong dimensions
X_new = np.random.rand(n_new_samples, 2 * n_features)
y_new = np.random.randint(0, 2, size=(n_new_samples, ))
self.assertRaises(ValueError, learner._add_training_data,
X_new, y_new)
def test_set_classes(self):
for n_classes in range(1, 10):
learner_list = [
modAL.models.ActiveLearner(estimator=mock.MockClassifier(
classes_=np.asarray([idx]))) for idx in range(n_classes)
]
committee = modAL.models.Committee(learner_list=learner_list)
np.testing.assert_equal(committee.classes_,
np.unique(range(n_classes)))
def test_score(self):
test_cases = (np.random.rand() for _ in range(10))
for score_return in test_cases:
mock_classifier = mock.MockClassifier(score_return=score_return)
learner = modAL.models.ActiveLearner(mock_classifier,
mock.MockFunction(None))
np.testing.assert_almost_equal(
learner.score(np.random.rand(5, 2), np.random.rand(5, )),
score_return)
def test_predict(self):
for n_samples in range(1, 100):
for n_features in range(1, 10):
X = np.random.rand(n_samples, n_features)
predict_return = np.random.randint(0, 2, size=(n_samples, ))
mock_classifier = mock.MockClassifier(
predict_return=predict_return)
learner = modAL.models.ActiveLearner(estimator=mock_classifier)
np.testing.assert_equal(learner.predict(X), predict_return)
def test_classifier_uncertainty(self):
test_cases = (Test(p * np.ones(shape=(k, l)), (1 - p) * np.ones(shape=(k, )))
for k in range(1, 100) for l in range(1, 10) for p in np.linspace(0, 1, 11))
for case in test_cases:
mock_classifier = mock.MockClassifier(predict_proba_return=case.input)
np.testing.assert_almost_equal(
modAL.uncertainty.classifier_uncertainty(mock_classifier, np.random.rand(10)),
case.output
)
def test_margin_sampling(self):
for n_samples in range(1, 10):
for n_classes in range(1, 10):
max_proba = np.zeros(n_classes)
for true_query_idx in range(n_samples):
predict_proba = np.random.rand(n_samples, n_classes)
predict_proba[true_query_idx] = max_proba
classifier = mock.MockClassifier(
predict_proba_return=predict_proba)
query_idx, query_instance = modAL.uncertainty.uncertainty_sampling(
classifier, np.random.rand(n_samples, n_classes))
np.testing.assert_array_equal(query_idx, true_query_idx)
def test_classifier_entropy(self):
for n_samples in range(1, 100):
for n_classes in range(1, 20):
proba = np.zeros(shape=(n_samples, n_classes))
for sample_idx in range(n_samples):
proba[sample_idx, np.random.choice(range(n_classes))] = 1.0
classifier = mock.MockClassifier(predict_proba_return=proba)
np.testing.assert_equal(
modAL.uncertainty.classifier_entropy(
classifier, np.random.rand(n_samples, 1)),
np.zeros(shape=(n_samples, )))
def test_classifier_margin(self):
test_cases_1 = (Test(p * np.ones(shape=(k, l)), np.zeros(shape=(k,)))
for k in range(1, 100) for l in range(1, 10) for p in np.linspace(0, 1, 11))
test_cases_2 = (Test(p * np.tile(np.asarray(range(k))+1.0, l).reshape(l, k),
p * np.ones(shape=(l, ))*int(k!=1))
for k in range(1, 10) for l in range(1, 100) for p in np.linspace(0, 1, 11))
for case in chain(test_cases_1, test_cases_2):
mock_classifier = mock.MockClassifier(predict_proba_return=case.input)
np.testing.assert_almost_equal(
modAL.uncertainty.classifier_margin(mock_classifier, np.random.rand(10)),
case.output
)
def test_predict(self):
for n_learners in range(1, 10):
for n_instances in range(1, 10):
prediction = np.random.randint(10,
size=(n_instances, n_learners))
committee = modAL.models.Committee(learner_list=[
mock.MockActiveLearner(
mock.MockClassifier(classes_=np.asarray([0])),
predict_return=prediction[:, learner_idx])
for learner_idx in range(n_learners)
])
np.testing.assert_equal(
committee.vote(np.random.rand(n_instances, 5)), prediction)
def test_vote_proba(self):
for n_samples in range(1, 100):
for n_learners in range(1, 10):
for n_classes in range(1, 10):
vote_proba_output = np.random.rand(n_samples, n_learners, n_classes)
# assembling the mock learners
learner_list = [mock.MockActiveLearner(
predict_proba_return=vote_proba_output[:, learner_idx, :],
predictor=mock.MockClassifier(classes_=list(range(n_classes)))
) for learner_idx in range(n_learners)]
committee = modAL.models.Committee(learner_list=learner_list)
np.testing.assert_almost_equal(
committee.vote_proba(np.random.rand(n_samples, 1)),
vote_proba_output
)
def test_vote(self):
for n_members in range(1, 10):
for n_instances in range(1, 100):
vote_output = np.random.randint(0, 2, size=(n_instances, n_members))
# assembling the Committee
learner_list = [mock.MockActiveLearner(
predict_return=vote_output[:, member_idx],
predictor=mock.MockClassifier(classes_=[0])
)
for member_idx in range(n_members)]
committee = modAL.models.Committee(learner_list=learner_list)
np.testing.assert_array_almost_equal(
committee.vote(np.random.rand(n_instances).reshape(-1, 1)),
vote_output
)
