def test_skope_rules():
"""Check various parameter settings."""
X_train = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [6, 3],
[-4, -7]]
y_train = [0] * 6 + [1] * 2
X_test = np.array([[2, 1], [1, 1]])
grid = ParameterGrid({
"feature_names": [None, ['a', 'b']],
"precision_min": [0.],
"recall_min": [0.],
"n_estimators": [1],
"max_samples": [0.5, 4],
"max_samples_features": [0.5, 2],
"bootstrap": [True, False],
"bootstrap_features": [True, False],
"max_depth": [2],
"max_features": ["auto", 1, 0.1],
"min_samples_split": [2, 0.1],
"n_jobs": [-1, 2]
})
with suppress_warnings():
for params in grid:
SkopeRulesClassifier(random_state=rng,
**params).fit(X_train,
y_train).predict(X_test)
# additional parameters:
SkopeRulesClassifier(n_estimators=50,
max_samples=1.,
recall_min=0.,
precision_min=0.).fit(X_train,
y_train).predict(X_test)
def test_f1_score():
clf = SkopeRulesClassifier()
rule0 = ('a > 0', (0, 0, 0))
rule1 = ('a > 0', (0.5, 0.5, 0))
rule2 = ('a > 0', (0.5, 0, 0))
assert clf.f1_score(rule0) == 0
assert clf.f1_score(rule1) == 0.5
assert clf.f1_score(rule2) == 0
def test_max_samples_attribute():
X = iris.data
y = iris.target
y = (y != 0)
clf = SkopeRulesClassifier(max_samples=1.).fit(X, y)
assert clf.max_samples_ == X.shape[0]
clf = SkopeRulesClassifier(max_samples=500)
assert_warns(UserWarning, clf.fit, X, y)
assert clf.max_samples_ == X.shape[0]
clf = SkopeRulesClassifier(max_samples=0.4).fit(X, y)
assert clf.max_samples_ == 0.4 * X.shape[0]
def test_performances():
X, y = make_blobs(n_samples=1000, random_state=0, centers=2)
# make labels imbalanced by remove all but 100 instances from class 1
indexes = np.ones(X.shape[0]).astype(bool)
ind = np.array([False] * 100 + list(((y == 1)[100:])))
indexes[ind] = 0
X = X[indexes]
y = y[indexes]
n_samples, n_features = X.shape
clf = SkopeRulesClassifier()
# fit
clf.fit(X, y)
# with lists
clf.fit(X.tolist(), y.tolist())
y_pred = clf.predict(X)
assert y_pred.shape == (n_samples, )
# training set performance
assert accuracy_score(y, y_pred) > 0.83
# decision_function agrees with predict
decision = -clf.decision_function(X)
assert decision.shape == (n_samples, )
dec_pred = (decision.ravel() < 0).astype(np.int)
assert_array_equal(dec_pred, y_pred)
def test_deduplication_works():
# toy sample (the last two samples are outliers)
X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [6, 3], [4, -7]]
y = [0] * 6 + [1] * 2
X_test = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [10, 5],
[5, -7]]
# Test LOF
clf = SkopeRulesClassifier(random_state=rng,
max_samples=1.,
max_depth_duplication=3)
clf.fit(X, y)
decision_func = clf.decision_function(X_test)
rules_vote = clf.rules_vote(X_test)
score_top_rules = clf.score_top_rules(X_test)
pred = clf.predict(X_test)
pred_score_top_rules = clf.predict_top_rules(X_test, 1)
assert True, 'deduplication works'
def test_skope_rules_works():
# toy sample (the last two samples are outliers)
X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [6, 3], [4, -7]]
y = [0] * 6 + [1] * 2
X_test = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [10, 5],
[5, -7]]
# Test LOF
clf = SkopeRulesClassifier(random_state=rng, max_samples=1.)
clf.fit(X, y)
decision_func = clf.decision_function(X_test)
rules_vote = clf.rules_vote(X_test)
score_top_rules = clf.score_top_rules(X_test)
pred = clf.predict(X_test)
pred_score_top_rules = clf.predict_top_rules(X_test, 1)
# assert detect outliers:
assert np.min(decision_func[-2:]) > np.max(decision_func[:-2])
assert np.min(rules_vote[-2:]) > np.max(rules_vote[:-2])
assert np.min(score_top_rules[-2:]) > np.max(score_top_rules[:-2])
assert_array_equal(pred, 6 * [0] + 2 * [1])
assert_array_equal(pred_score_top_rules, 6 * [0] + 2 * [1])
def test_skope_rules_error():
"""Test that it gives proper exception on deficient input."""
X = iris.data
y = iris.target
y = (y != 0)
# Test max_samples
assert_raises(ValueError, SkopeRulesClassifier(max_samples=-1).fit, X, y)
assert_raises(ValueError, SkopeRulesClassifier(max_samples=0.0).fit, X, y)
assert_raises(ValueError, SkopeRulesClassifier(max_samples=2.0).fit, X, y)
# explicitly setting max_samples > n_samples should result in a warning.
assert_warns(UserWarning, SkopeRulesClassifier(max_samples=1000).fit, X, y)
assert_no_warnings(SkopeRulesClassifier(max_samples=np.int64(2)).fit, X, y)
assert_raises(ValueError,
SkopeRulesClassifier(max_samples='foobar').fit, X, y)
assert_raises(ValueError, SkopeRulesClassifier(max_samples=1.5).fit, X, y)
assert_raises(ValueError,
SkopeRulesClassifier(max_depth_duplication=1.5).fit, X, y)
assert_raises(ValueError,
SkopeRulesClassifier().fit(X, y).predict, X[:, 1:])
assert_raises(ValueError,
SkopeRulesClassifier().fit(X, y).decision_function, X[:, 1:])
assert_raises(ValueError,
SkopeRulesClassifier().fit(X, y).rules_vote, X[:, 1:])
assert_raises(ValueError,
SkopeRulesClassifier().fit(X, y).score_top_rules, X[:, 1:])