def test_dynamic_weighted_majority():
stream = SEAGenerator(1, noise_percentage=0.067, random_state=112)
stream.prepare_for_use()
learner = DynamicWeightedMajorityClassifier(3, NaiveBayes(), beta=0.5, theta=0.01)
cnt = 0
max_samples = 5000
predictions = []
wait_samples = 100
correct_predictions = 0
first = True
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
if y[0] == predictions[-1]:
correct_predictions += 1
if first:
learner.partial_fit(X, y, classes=stream.target_values)
first = False
else:
learner.partial_fit(X, y)
cnt += 1
performance = correct_predictions / len(predictions)
expected_predictions = [1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1,
0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,
0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]
expected_correct_predictions = 44
expected_performance = 0.8979591836734694
assert np.alltrue(predictions == expected_predictions)
assert np.isclose(expected_performance, performance)
assert correct_predictions == expected_correct_predictions
assert type(learner.predict(X)) == np.ndarray
expected_info = 'DynamicWeightedMajorityClassifier(base_estimator=NaiveBayes(nominal_attributes=None),\n' \
' beta=0.5, n_estimators=3, period=50,\n' \
' theta=0.01)'
assert learner.get_info() == expected_info
def test_hoeffding_tree_coverage():
# Cover memory management
stream = SEAGenerator(random_state=1, noise_percentage=0.05)
stream.prepare_for_use()
X, y = stream.next_sample(5000)
learner = HoeffdingTree(max_byte_size=30, memory_estimate_period=100, grace_period=10, leaf_prediction='mc')
learner.partial_fit(X, y, classes=stream.target_values)
learner.reset()
# Cover nominal attribute observer
stream = RandomTreeGenerator(tree_random_state=1, sample_random_state=1, n_num_features=0,
n_categories_per_cat_feature=2)
stream.prepare_for_use()
X, y = stream.next_sample(1000)
learner = HoeffdingTree(leaf_prediction='mc', nominal_attributes=[i for i in range(10)])
learner.partial_fit(X, y, classes=stream.target_values)
def test_online_boosting():
stream = SEAGenerator(1, noise_percentage=0.067, random_state=112)
stream.prepare_for_use()
nb = NaiveBayes()
learner = OnlineBoosting(base_estimator=nb,
n_estimators=3,
random_state=112)
first = True
cnt = 0
max_samples = 5000
predictions = []
wait_samples = 100
correct_predictions = 0
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
if y[0] == predictions[-1]:
correct_predictions += 1
if first:
learner.partial_fit(X, y, classes=stream.target_values)
first = False
else:
learner.partial_fit(X, y)
cnt += 1
performance = correct_predictions / len(predictions)
expected_predictions = [
1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0,
1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
1
]
expected_correct_predictions = 45
expected_performance = 0.9183673469387755
assert np.alltrue(predictions == expected_predictions)
assert np.isclose(expected_performance, performance)
assert correct_predictions == expected_correct_predictions
assert type(learner.predict(X)) == np.ndarray
assert type(learner.predict_proba(X)) == np.ndarray
def test_leverage_bagging():
stream = SEAGenerator(1, noise_percentage=0.067, random_state=112)
stream.prepare_for_use()
knn = KNN(n_neighbors=8, leaf_size=40, max_window_size=2000)
learner = LeverageBagging(base_estimator=knn,
n_estimators=3,
random_state=112)
first = True
cnt = 0
max_samples = 5000
predictions = []
wait_samples = 100
correct_predictions = 0
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
if y[0] == predictions[-1]:
correct_predictions += 1
if first:
learner.partial_fit(X, y, classes=stream.target_values)
first = False
else:
learner.partial_fit(X, y)
cnt += 1
performance = correct_predictions / len(predictions)
expected_predictions = [
1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0,
1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
1
]
expected_correct_predictions = 42
expected_performance = 0.8571428571428571
assert np.alltrue(predictions == expected_predictions)
assert np.isclose(expected_performance, performance)
assert correct_predictions == expected_correct_predictions
assert type(learner.predict(X)) == np.ndarray
assert type(learner.predict_proba(X)) == np.ndarray
def test_sam_knn_coverage():
stream = SEAGenerator(random_state=1)
stream.prepare_for_use()
hyperParams = {'maxSize': 50,
'n_neighbors': 3,
'weighting': 'uniform',
'stm_size_option': 'maxACC',
'min_stm_size': 10,
'use_ltm': True}
learner = SAMKNN(n_neighbors=hyperParams['n_neighbors'],
max_window_size=hyperParams['maxSize'],
weighting=hyperParams['weighting'],
stm_size_option=hyperParams['stm_size_option'],
min_stm_size=hyperParams['min_stm_size'],
use_ltm=hyperParams['use_ltm'])
cnt = 0
max_samples = 1000
predictions = array('i')
wait_samples = 20
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
learner.partial_fit(X, y)
cnt += 1
expected_predictions = array('i', [1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 0, 0, 1, 1, 1, 1, 1, 0,
0, 1, 1, 1, 1, 1, 0, 1, 1, 1,
1, 1, 1, 1, 0, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 1, 1, 1, 0])
assert np.alltrue(predictions == expected_predictions)
expected_info = "SAMKNN(ltm_size=0.4, max_window_size=None, min_stm_size=10, n_neighbors=3,\n" \
" stm_size_option='maxACC', use_ltm=True, weighting='uniform')"
assert learner.get_info() == expected_info
def test_hoeffding_anytime_tree_coverage():
# Cover memory management
stream = SEAGenerator(random_state=1, noise_percentage=0.05)
stream.prepare_for_use()
X, y = stream.next_sample(5000)
learner = HATT(max_byte_size=30, memory_estimate_period=100, grace_period=10, leaf_prediction='nba')
learner.partial_fit(X, y, classes=stream.target_values)
learner.reset()
# Cover nominal attribute observer
stream = RandomTreeGenerator(tree_random_state=23, sample_random_state=12, n_classes=2, n_cat_features=2,
n_categories_per_cat_feature=4, n_num_features=1, max_tree_depth=30, min_leaf_depth=10,
fraction_leaves_per_level=0.45)
stream.prepare_for_use()
X, y = stream.next_sample(5000)
learner = HATT(leaf_prediction='nba', nominal_attributes=[i for i in range(1, 9)])
learner.partial_fit(X, y, classes=stream.target_values)
def test_evaluate_coverage(tmpdir):
from skmultiflow.data import SEAGenerator
from skmultiflow.bayes import NaiveBayes
max_samples = 1000
# Stream
stream = SEAGenerator(random_state=1)
stream.prepare_for_use()
# Learner
nb = NaiveBayes()
output_file = os.path.join(str(tmpdir), "prequential_summary.csv")
metrics = ['running_time', 'model_size']
evaluator = EvaluatePrequential(max_samples=max_samples,
metrics=metrics,
data_points_for_classification=True,
output_file=output_file)
evaluator.evaluate(stream=stream, model=nb, model_names=['NB'])
def test_additive_expert_ensemble_oldest():
stream = SEAGenerator(1, noise_percentage=0.067, random_state=112)
stream.prepare_for_use()
learner = AdditiveExpertEnsembleClassifier(10, NaiveBayes(), beta=0.5, gamma=0.1,
pruning='oldest')
cnt = 0
max_samples = 5000
predictions = []
wait_samples = 100
correct_predictions = 0
first = True
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
if y[0] == predictions[-1]:
correct_predictions += 1
if first:
learner.partial_fit(X, y, classes=stream.target_values)
first = False
else:
learner.partial_fit(X, y)
cnt += 1
performance = correct_predictions / len(predictions)
expected_predictions = [1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1,
0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0,
0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]
expected_correct_predictions = 39
expected_performance = 0.7959183673469388
assert np.alltrue(predictions == expected_predictions)
assert np.isclose(expected_performance, performance)
assert correct_predictions == expected_correct_predictions
assert type(learner.predict(X)) == np.ndarray
def test_sam_knn():
stream = SEAGenerator(random_state=1)
stream.prepare_for_use()
hyperParams = {'maxSize': 1000, 'nNeighbours': 5, 'knnWeights': 'distance', 'STMSizeAdaption': 'maxACCApprox',
'use_ltm': False}
learner = SAMKNNClassifier(n_neighbors=hyperParams['nNeighbours'], max_window_size=hyperParams['maxSize'],
weighting=hyperParams['knnWeights'],
stm_size_option=hyperParams['STMSizeAdaption'], use_ltm=hyperParams['use_ltm'])
cnt = 0
max_samples = 5000
predictions = array('d')
wait_samples = 100
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
learner.partial_fit(X, y)
cnt += 1
expected_predictions = array('i', [1, 1, 1, 0, 1, 1, 0, 0, 0, 1,
1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0, 0, 0, 1, 1,
1, 1, 0, 1, 0, 0, 1, 0, 1])
assert np.alltrue(predictions == expected_predictions)
assert type(learner.predict(X)) == np.ndarray
with pytest.raises(NotImplementedError):
learner.predict_proba(X)
from skmultiflow.data.file_stream import FileStream
import numpy as np
from Goowe import Goowe
from skmultiflow.data import SEAGenerator
import logging
from GooweMS import GooweMS
import random
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# Prepare the data stream
stream_1 = SEAGenerator()
stream_2 = SEAGenerator()
stream_3 = SEAGenerator()
stream_1.prepare_for_use()
stream_2.prepare_for_use()
stream_3.prepare_for_use()
ENSEMBLE_TYPE = 'av'
instances_num = 10000
instances_counter = 0
num_features = stream_1.n_features
num_targets = stream_1.n_targets
num_classes = 2
target_values = [0., 1.]
logging.info("\n\tStreams are generated and prepared for use.\n\tNumber of features: {0} - Number of targets: {1} - Number of classes: {2} - Target values: {3}"
.format(num_features, num_targets, num_classes, target_values))
N_MAX_CLASSIFIERS = 15
CHUNK_SIZE = 500 # User-specified
WINDOW_SIZE = 100 # User-specified
def test_learn_nse():
stream = SEAGenerator(random_state=2212)
stream.prepare_for_use()
estimator = GaussianNB()
corrects, acc, classifier = run_classifier(estimator, stream)
expected_correct_predictions = 1754
expected_acc = 0.877
assert np.isclose(expected_acc, acc)
assert corrects == expected_correct_predictions
# Test reset method
classifier.reset()
assert len(classifier.ensemble) == 0
assert len(classifier.ensemble_weights) == 0
assert len(classifier.bkts) == 0
assert len(classifier.wkts) == 0
assert len(classifier.X_batch) == 0
assert len(classifier.y_batch) == 0
expected_info = 'LearnPPNSEClassifier(base_estimator=GaussianNB(priors=None, var_smoothing=1e-09),\n' \
' crossing_point=10, n_estimators=15, pruning=None,\n' \
' slope=0.5, window_size=250)'
assert classifier.get_info() == expected_info
# test pruning error
corrects, acc, classifier = run_classifier(estimator,
stream,
pruning="error",
ensemble_size=5)
expected_correct_predictions = 1751
expected_acc = 0.8755
assert np.isclose(expected_acc, acc)
assert corrects == expected_correct_predictions
# test pruning age
corrects, acc, classifier = run_classifier(estimator,
stream,
pruning="age",
ensemble_size=5)
expected_correct_predictions = 1774
expected_acc = 0.887
assert np.isclose(expected_acc, acc)
assert corrects == expected_correct_predictions
stream = SEAGenerator(random_state=2212)
stream.prepare_for_use()
estimator = HoeffdingTreeClassifier()
classifier = LearnPPNSEClassifier(base_estimator=estimator)
# Keeping track of sample count and correct prediction count
sample_count = 0
corrects = 0
m = 250
# Pre training the classifier
X, y = stream.next_sample(m)
classifier.partial_fit(X, y, classes=stream.target_values)
# print(classifier.ensemble_weights)
for i in range(10):
X, y = stream.next_sample(m)
pred = classifier.predict(X)
classifier.partial_fit(X, y)
if pred is not None:
# print(pred)
corrects += np.sum(y == pred)
sample_count += m
acc = corrects / sample_count
expected_acc = 0.9436
assert acc == expected_acc
def test_rslvq():
stream = SEAGenerator(random_state=1)
stream.prepare_for_use()
learner_adadelta = RSLVQ(gradient_descent='adadelta')
learner_vanilla = RSLVQ(gradient_descent='vanilla')
cnt = 0
max_samples = 5000
y_pred_vanilla = array('i')
y_pred_adadelta = array('i')
X_batch = []
y_batch = []
wait_samples = 100
# Check if predicted labels are as expected
while cnt < max_samples:
X, y = stream.next_sample()
X_batch.append(X[0])
y_batch.append(y[0])
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
y_pred_vanilla.append(learner_vanilla.predict(X)[0])
y_pred_adadelta.append(learner_adadelta.predict(X)[0])
learner_adadelta.partial_fit(X, y, classes=stream.target_values)
learner_vanilla.partial_fit(X, y, classes=stream.target_values)
cnt += 1
expected_predictions_vanilla = array('i', [
1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,
0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,
1
])
expected_predictions_adadelta = array('i', [
1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0,
1
])
assert np.alltrue(y_pred_vanilla == expected_predictions_vanilla)
assert np.alltrue(y_pred_adadelta == expected_predictions_adadelta)
# Check get_info method
expected_info = "RobustSoftLearningVectorQuantization(gamma=0.9, gradient_descent='vanilla',\n initial_prototypes=None,\n prototypes_per_class=1, random_state=None,\n sigma=1.0)"
assert learner_vanilla.get_info() == expected_info
# Check reset method
learner_vanilla.reset()
learner_vanilla.fit(X=np.array(X_batch[:4500]), y=np.array(y_batch[:4500]))
learner_adadelta.reset()
learner_adadelta.fit(X=np.array(X_batch[:4500]),
y=np.array(y_batch[:4500]))
# Check classifiers performance
learner_w_init_ppt = RSLVQ(
initial_prototypes=[[2.59922826, 2.57368134, 4.92501, 0],
[6.05801971, 6.01383352, 5.02135783, 1]],
gradient_descent='adadelta')
learner_w_init_ppt.fit(X=np.array(X_batch[:4500]),
y=np.array(y_batch[:4500]))
expected_score_ppt = .9539078156312625
assert np.isclose(
expected_score_ppt,
learner_w_init_ppt.score(X=np.array(X_batch[4501:]),
y=np.array(y_batch[4501:])))
expected_score_vanilla = .8897795591182365
assert np.isclose(
expected_score_vanilla,
learner_vanilla.score(X=np.array(X_batch[4501:]),
y=np.array(y_batch[4501:])))
expected_score_adadelta = .9458917835671342
assert np.isclose(
expected_score_adadelta,
learner_adadelta.score(X=np.array(X_batch[4501:]),
y=np.array(y_batch[4501:])))
# Check types
assert is_classifier(learner_vanilla)
assert is_classifier(learner_adadelta)
assert type(learner_vanilla.predict(X)) == np.ndarray
assert type(learner_adadelta.predict(X)) == np.ndarray
# Check prototypes after learning
expected_prototypes = np.array([[2.59922826, 2.57368134, 4.92501],
[6.05801971, 6.01383352, 5.02135783]])
assert np.allclose(learner_adadelta.prototypes, expected_prototypes)
def test_learn_nse():
stream = SEAGenerator(random_state=2212)
stream.prepare_for_use()
estimator = GaussianNB()
corrects, acc, classifier = run_classifier(estimator, stream)
expected_correct_predictions = 1754
expected_acc = 0.877
assert np.isclose(expected_acc, acc)
assert corrects == expected_correct_predictions
# Test reset method
classifier.reset()
assert len(classifier.ensemble) == 0
assert len(classifier.ensemble_weights) == 0
assert len(classifier.bkts) == 0
assert len(classifier.wkts) == 0
assert len(classifier.X_batch) == 0
assert len(classifier.y_batch) == 0
assert classifier.get_info() == "LearnNSE: base_estimator: <class 'sklearn.naive_bayes.GaussianNB'> - " \
"ensemble_size: <class 'int'> - " \
"period: <class 'int'> - " \
"slope: <class 'float'> - " \
"crossing_point: <class 'int'> - " \
"pruning: <class 'NoneType'>"
# test pruning error
corrects, acc, classifier = run_classifier(estimator,
stream,
pruning="error",
ensemble_size=5)
expected_correct_predictions = 1751
expected_acc = 0.8755
assert np.isclose(expected_acc, acc)
assert corrects == expected_correct_predictions
# test pruning age
corrects, acc, classifier = run_classifier(estimator,
stream,
pruning="age",
ensemble_size=5)
expected_correct_predictions = 1774
expected_acc = 0.887
assert np.isclose(expected_acc, acc)
assert corrects == expected_correct_predictions
stream = SEAGenerator(random_state=2212)
stream.prepare_for_use()
estimator = HoeffdingTree()
classifier = LearnNSE(base_estimator=estimator)
# Keeping track of sample count and correct prediction count
sample_count = 0
corrects = 0
m = 250
# Pre training the classifier
X, y = stream.next_sample(m)
classifier.partial_fit(X, y, classes=stream.target_values)
# print(classifier.ensemble_weights)
for i in range(10):
X, y = stream.next_sample(m)
pred = classifier.predict(X)
classifier.partial_fit(X, y)
if pred is not None:
# print(pred)
corrects += np.sum(y == pred)
sample_count += m
acc = corrects / sample_count
expected_acc = 0.9436
assert acc == expected_acc
def test_knn():
stream = SEAGenerator(random_state=1)
stream.prepare_for_use()
learner = KNNClassifier(n_neighbors=8, max_window_size=2000, leaf_size=40)
cnt = 0
max_samples = 5000
predictions = array('i')
correct_predictions = 0
wait_samples = 100
X_batch = []
y_batch = []
while cnt < max_samples:
X, y = stream.next_sample()
X_batch.append(X[0])
y_batch.append(y[0])
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
if y[0] == predictions[-1]:
correct_predictions += 1
learner.partial_fit(X, y)
cnt += 1
expected_predictions = array('i', [
1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,
1
])
assert np.alltrue(predictions == expected_predictions)
expected_correct_predictions = 49
assert correct_predictions == expected_correct_predictions
expected_info = 'KNNClassifier(leaf_size=40, max_window_size=2000, n_neighbors=8, nominal_attributes=None)'
info = " ".join([line.strip() for line in learner.get_info().split()])
assert info == expected_info
learner.reset()
info = " ".join([line.strip() for line in learner.get_info().split()])
assert info == expected_info
X_batch = np.array(X_batch)
y_batch = np.array(y_batch)
learner.fit(X_batch[:4500], y_batch[:4500], classes=[0, 1])
predictions = learner.predict(X_batch[4501:4550])
expected_predictions = array('i', [
1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1,
1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,
0
])
assert np.alltrue(predictions == expected_predictions)
correct_predictions = sum(predictions == y_batch[4501:4550])
expected_correct_predictions = 49
assert correct_predictions == expected_correct_predictions
assert type(learner.predict(X)) == np.ndarray
assert type(learner.predict_proba(X)) == np.ndarray
def test_perceptron(test_path):
stream = SEAGenerator(random_state=1)
stream.prepare_for_use()
learner = PerceptronMask(random_state=1)
cnt = 0
max_samples = 5000
y_pred = array('i')
X_batch = []
y_batch = []
y_proba = []
wait_samples = 100
while cnt < max_samples:
X, y = stream.next_sample()
X_batch.append(X[0])
y_batch.append(y[0])
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
y_pred.append(learner.predict(X)[0])
y_proba.append(learner.predict_proba(X)[0])
learner.partial_fit(X, y, classes=stream.target_values)
cnt += 1
expected_predictions = array('i', [
1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0,
1
])
assert np.alltrue(y_pred == expected_predictions)
test_file = os.path.join(test_path, 'data_perceptron_proba.npy')
y_proba_expected = np.load(test_file)
assert np.allclose(y_proba, y_proba_expected)
expected_info = "PerceptronMask(alpha=0.0001, class_weight=None, early_stopping=False, eta0=1.0,\n" \
" fit_intercept=True, max_iter=None, n_iter=None,\n" \
" n_iter_no_change=5, n_jobs=None, penalty=None, random_state=1,\n" \
" shuffle=True, tol=None, validation_fraction=0.1, verbose=0,\n" \
" warm_start=False)"
assert learner.get_info() == expected_info
# Coverage tests
learner.reset()
if not sklearn_version.startswith("0.21"):
learner.fit(X=np.asarray(X_batch[:4500]),
y=np.asarray(y_batch[:4500]),
classes=stream.target_values)
else:
# Root cause of failure (TypeError: an integer is required) is in the fit() method in sklearn 0.21.0,
# This is a workaround until a fix is made available in sklearn
learner.partial_fit(X=np.asarray(X_batch[:4500]),
y=np.asarray(y_batch[:4500]),
classes=stream.target_values)
y_pred = learner.predict(X=X_batch[4501:])
accuracy = accuracy_score(y_true=y_batch[4501:], y_pred=y_pred)
expected_accuracy = 0.9478957915831663
assert np.isclose(expected_accuracy, accuracy)
assert type(learner.predict(X)) == np.ndarray
assert type(learner.predict_proba(X)) == np.ndarray
########################################
from sklearn.linear_model import SGDClassifier
from skmultiflow.data import SEAGenerator
from skmultiflow.evaluation import EvaluatePrequential
# We will use the `SEA` stream generator
stream = SEAGenerator(classification_function=2, random_state=1)
# Prepare the stream for use
stream.prepare_for_use()
# Setup a classifier, in this case `Linear SVM` with `SGD` training*
classifier = SGDClassifier()
# Setup the evaluator, we will use prequential evaluation
eval = EvaluatePrequential(
show_plot=True,
max_samples=20000,
metrics=['accuracy', 'kappa', 'running_time', 'model_size'])
# Run the evaluation
eval.evaluate(stream=stream, model=classifier, model_names=['SVM-SGD'])
