def __init__(self, base_estimator=KNNADWINClassifier(), n_estimators=10, sampling_rate=3, algorithm=1, drift_detection=True, random_state=None): super().__init__() self.base_estimator = base_estimator self.n_estimators = n_estimators self.random_state = random_state self.sampling_rate = sampling_rate self.algorithm = algorithm self.drift_detection = drift_detection # default values self.ensemble = None self.actual_n_estimators = None self.classes = None self._random_state = None self.adwin_ensemble = None self.lam_sc = None self.lam_pos = None self.lam_neg = None self.lam_sw = None self.epsilon = None self.__configure()
def OzaBagging(base_estimator=KNNADWINClassifier(), n_estimators=10, random_state=None): # pragma: no cover warnings.warn("'OzaBagging' has been renamed to 'OzaBaggingClassifier' in v0.5.0.\n" "The old name will be removed in v0.7.0", category=FutureWarning) return OzaBaggingClassifier(base_estimator=base_estimator, n_estimators=n_estimators, random_state=random_state)
def __init__(self, base_estimator=KNNADWINClassifier(), n_estimators=10, cost_positive=1, cost_negative=0.1, drift_detection=True, random_state=None): super().__init__() # default values self.ensemble = None self.actual_n_estimators = None self.classes = None self._random_state = None self.base_estimator = base_estimator self.n_estimators = n_estimators self.cost_positive = cost_positive self.cost_negative = cost_negative self.drift_detection = drift_detection self.random_state = random_state self.adwin_ensemble = None self.lam_fn = None self.lam_fp = None self.lam_sum = None self.lam_sw = None self.werr = None self.epsilon = None
def OnlineBoosting(base_estimator=KNNADWINClassifier(), n_estimators=10, drift_detection=True, random_state=None): # pragma: no cover warnings.warn("'OnlineBoosting' has been renamed to 'OnlineBoostingClassifier' in v0.5.0.\n" "The old name will be removed in v0.7.0", category=FutureWarning) return OnlineBoostingClassifier(base_estimator=base_estimator, n_estimators=n_estimators, drift_detection=drift_detection, random_state=random_state)
def __init__(self, base_estimator=KNNADWINClassifier(), n_estimators=10, random_state=None): super().__init__(base_estimator, n_estimators, random_state) # default values self.adwin_ensemble = None self.__configure()
def test_knn_adwin(): stream = ConceptDriftStream(stream=SEAGenerator(random_state=1), drift_stream=SEAGenerator( random_state=2, classification_function=2), random_state=1, position=250, width=10) learner = KNNADWINClassifier(n_neighbors=8, leaf_size=40, max_window_size=200) cnt = 0 max_samples = 1000 predictions = array('i') correct_predictions = 0 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]) if y[0] == predictions[-1]: correct_predictions += 1 learner.partial_fit(X, y) cnt += 1 expected_predictions = array('i', [ 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1 ]) assert np.alltrue(predictions == expected_predictions) expected_correct_predictions = 46 assert correct_predictions == expected_correct_predictions learner.reset() assert learner.data_window.size == 0 expected_info = "KNNADWINClassifier(leaf_size=40, max_window_size=200, " \ "metric='euclidean', n_neighbors=8)" info = " ".join([line.strip() for line in learner.get_info().split()]) assert info == expected_info stream.restart() X, y = stream.next_sample(max_samples) learner.fit(X[:950], y[:950]) predictions = learner.predict(X[951:]) correct_predictions = sum(np.array(predictions) == y[951:]) expected_correct_predictions = 47 assert correct_predictions == expected_correct_predictions assert type(learner.predict(X)) == np.ndarray assert type(learner.predict_proba(X)) == np.ndarray
def OnlineAdaC2(base_estimator=KNNADWINClassifier(), n_estimators=10, cost_positive=1, cost_negative=0.1, drift_detection=True, random_state=None): # pragma: no cover warnings.warn("'OnlineAdaC2' has been renamed to 'OnlineAdaC2Classifier' in v0.5.0.\n" "The old name will be removed in v0.7.0", category=FutureWarning) return OnlineAdaC2Classifier(base_estimator=base_estimator, n_estimators=n_estimators, cost_positive=cost_positive, cost_negative=cost_negative, drift_detection=drift_detection, random_state=random_state)
def __init__(self, base_estimator=KNNADWINClassifier(), n_estimators=10, random_state=None): super().__init__() # default values self.ensemble = None self.actual_n_estimators = None self.classes = None self._random_state = None # This is the actual random_state object used internally self.base_estimator = base_estimator self.n_estimators = n_estimators self.random_state = random_state self.__configure()
def __init__(self, base_estimator=KNNADWINClassifier(), n_estimators=10, sampling_rate=1, drift_detection=True, random_state=None): super().__init__() self.base_estimator = base_estimator self.n_estimators = n_estimators self._init_random_state = random_state self.sampling_rate = sampling_rate self.drift_detection = drift_detection # default values self.ensemble = None self.actual_n_estimators = None self.classes = None self._random_state = None self.adwin_ensemble = None
def demo(): """ _test_oza_bagging_adwin This demo tests the OzaBaggingADWINClassifier using KNNADWINClassifier as base estimator on samples given by a SEAGenerator. The test computes the performance of the OzaBaggingADWINClassifier as well as the time to create the structure and classify max_samples (20000 by default) instances. """ logging.basicConfig(format='%(message)s', level=logging.INFO) warnings.filterwarnings("ignore", ".*Passing 1d.*") stream = SEAGenerator(1, noise_percentage=0.067, random_state=1) clf = OzaBaggingADWINClassifier(base_estimator=KNNADWINClassifier( n_neighbors=8, max_window_size=2000, leaf_size=30), n_estimators=2, random_state=1) sample_count = 0 correctly_classified = 0 max_samples = 20000 train_size = 10 first = True if train_size > 0: X, y = stream.next_sample(train_size) clf.partial_fit(X, y, classes=stream.target_values) first = False while sample_count < max_samples: if sample_count % (max_samples / 20) == 0: logging.info('%s%%', str((sample_count // (max_samples / 20) * 5))) X, y = stream.next_sample() my_pred = clf.predict(X) if first: clf.partial_fit(X, y, classes=stream.target_values) first = False else: clf.partial_fit(X, y) if my_pred is not None: if y[0] == my_pred[0]: correctly_classified += 1 sample_count += 1 print(str(sample_count) + ' samples analyzed.') print('My performance: ' + str(correctly_classified / sample_count))
def test_pipeline(test_path): n_categories = 5 # Load test data generated using: # RandomTreeGenerator(tree_random_state=1, sample_random_state=1, # n_cat_features=n_categories, n_num_features=0) test_file = os.path.join(test_path, 'data-one-hot.npz') data = np.load(test_file) X = data['X'] y = data['y'] stream = DataStream(data=X, y=y.astype(np.int)) # Setup transformer cat_att_idx = [[i + j for i in range(n_categories)] for j in range(0, n_categories * n_categories, n_categories) ] transformer = OneHotToCategorical(categorical_list=cat_att_idx) # Set up the classifier classifier = KNNADWINClassifier(n_neighbors=2, max_window_size=50, leaf_size=40) # Setup the pipeline pipe = Pipeline([('one-hot', transformer), ('KNNADWINClassifier', classifier)]) # Setup the evaluator evaluator = EvaluatePrequential(show_plot=False, pretrain_size=10, max_samples=100) # Evaluate evaluator.evaluate(stream=stream, model=pipe) metrics = evaluator.get_mean_measurements() expected_accuracy = 0.5555555555555556 assert np.isclose(expected_accuracy, metrics[0].accuracy_score()) expected_kappa = 0.11111111111111116 assert np.isclose(expected_kappa, metrics[0].kappa_score()) print(pipe.get_info()) expected_info = "Pipeline: [OneHotToCategorical(categorical_list=[[0, 1, 2, 3, 4], " \ "[5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19], " \ "[20, 21, 22, 23, 24]]) KNNADWINClassifier(leaf_size=40, " \ "max_window_size=50, metric='euclidean', n_neighbors=2)]" info = " ".join([line.strip() for line in pipe.get_info().split()]) assert info == expected_info
def test_pipeline(test_path): n_categories = 5 test_file = os.path.join(test_path, 'data-one-hot.npz') data = np.load(test_file) data_as_dict = [] for i in range(0, len(data['X'])): data_as_dict.append({ 'X': data['X'][i].reshape(1, 25), 'y': np.array(data['y'][i]).reshape(1, 1) }) # Setup transformer cat_att_idx = [[i + j for i in range(n_categories)] for j in range(0, n_categories * n_categories, n_categories) ] transformer = OneHotToCategorical(categorical_list=cat_att_idx) # Set up the classifier classifier = KNNADWINClassifier(n_neighbors=2, max_window_size=50, leaf_size=40) # Setup the pipeline pipe = Pipeline([('one-hot', transformer), ('KNNADWINClassifier', classifier)]) train_eval_trigger = PrequentialTrigger(10) reporter = BufferedMetricsReporter(retrieve_metrics) results_observer = MetricsResultObserver(ClassificationMeasurements(), reporter) evaluation_event_observer = EvaluationEventObserver( pipe, train_eval_trigger, [results_observer], [0, 1]) data_source = ArrayDataSource(record_to_dictionary, [evaluation_event_observer], data_as_dict) data_source.listen_for_events() time.sleep(3) expected_accuracy = 0.5555555555555556 expected_kappa = 0.11111111111111116 assert np.isclose(expected_accuracy, reporter.get_buffer()['accuracy']) assert np.isclose(expected_kappa, reporter.get_buffer()['kappa'])
dstream = SEAGenerator(classification_function=2, balance_classes=True, noise_percentage=0.3, random_state=333) #Retrieve five samples dstream.next_sample(5) # Output: #(array([[3.68721825, 0.48303666, 1.04530188], # [2.45403315, 8.73489354, 0.51611639], # [2.38740114, 2.03699194, 1.74533621], # [9.41738118, 4.66915281, 9.59978205], # [1.05404748, 0.42265956, 2.44130999]]), array([1, 0, 0, 1, 1])) # Instatntiate the KNN ADWIN classifier method adwin_knn_class = KNNADWINClassifier(n_neighbors=10, max_window_size=1000) # Prequential Evaluation evaluate1 = EvaluatePrequential(show_plot=False, pretrain_size=1000, max_samples=10000, metrics=['accuracy']) # Run the evaluation evaluate1.evaluate(stream=dstream, model=adwin_knn_class) ################################################### # Applying SAM-KNN Classifier on the synthetic data stream from skmultiflow.lazy import SAMKNNClassifier from skmultiflow.evaluation import EvaluatePrequential from skmultiflow.data.sea_generator import SEAGenerator
def demo(instances=2000): """ _test_comparison_prequential This demo will test a prequential evaluation when more than one learner is passed, which makes it a comparison task. Parameters ---------- instances: int The evaluation's maximum number of instances. """ # Stream setup stream = FileStream( "https://raw.githubusercontent.com/scikit-multiflow/streaming-datasets/" "master/covtype.csv") # stream = SEAGenerator(classification_function=2, sample_seed=53432, balance_classes=False) # Setup the classifier clf = SGDClassifier() # classifier = KNNADWINClassifier(n_neighbors=8, max_window_size=2000,leaf_size=40, nominal_attributes=None) # classifier = OzaBaggingADWINClassifier(base_estimator=KNNClassifier(n_neighbors=8, max_window_size=2000, # leaf_size=30)) clf_one = KNNADWINClassifier(n_neighbors=8, max_window_size=1000, leaf_size=30) # clf_two = KNNClassifier(n_neighbors=8, max_window_size=1000, leaf_size=30) # clf_two = LeveragingBaggingClassifier(base_estimator=KNNClassifier(), n_estimators=2) t_one = OneHotToCategorical([[10, 11, 12, 13], [ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 ]]) # t_two = OneHotToCategorical([[10, 11, 12, 13], # [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, # 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, # 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53]]) pipe_one = Pipeline([('one_hot_to_categorical', t_one), ('KNNClassifier', clf_one)]) # pipe_two = Pipeline([('one_hot_to_categorical', t_two), ('KNNClassifier', clf_two)]) classifier = [clf, pipe_one] # classifier = SGDRegressor() # classifier = PerceptronMask() # Setup the pipeline # pipe = Pipeline([('Classifier', classifier)]) # Setup the evaluator evaluator = EvaluatePrequential( pretrain_size=2000, output_file='test_comparison_prequential.csv', max_samples=instances, batch_size=1, n_wait=200, max_time=1000, show_plot=True) # Evaluate evaluator.evaluate(stream=stream, model=classifier)
parser.add_argument('-s', '--label_size', required=False, default=0.25, help="Name of Detector {KD3/Adwin/PageHinkley}") args = parser.parse_args() test_dataset = args.dataset print("dataset:" + "datasets/" + test_dataset + '.csv') stream = FileStream("datasets/" + test_dataset + '.csv') #print(stream.get_target_values()) onlineBoosting = OnlineBoostingClassifier() knn_adwin = KNNADWINClassifier(n_neighbors=8, leaf_size=40, max_window_size=1000) SAMKNN = SAMKNNClassifier(n_neighbors=10, weighting='distance', max_window_size=500, stm_size_option='maxACCApprox', use_ltm=False) learn_pp_nse = LearnPPNSEClassifier() SGD = SGDClassifier() rslvq = RobustSoftLearningVectorQuantization() #CMMM2 = CMGMMClassifier(classes=stream.get_target_values(), prune_component=True, drift_detector=None) #CMMM.train(train_dataset, 'label', 'mfcc') # eval = WeakEvaluatePrequential( show_plot=False,
def demo(): """ _test_knn_adwin This demo tests the KNNADWINClassifier on a file stream, which gives instances coming from a SEA generator. The test computes the performance of the KNNADWINClassifier as well as the time to create the structure and classify max_samples (10000 by default) instances. """ start = timer() logging.basicConfig(format='%(message)s', level=logging.INFO) # warnings.filterwarnings("ignore", ".*Passing 1d.*") stream = FileStream( "https://raw.githubusercontent.com/scikit-multiflow/streaming-datasets/" "master/sea_big.csv", -1, 1) # stream = RandomRBFGeneratorDrift(change_speed=41.00, n_centroids=50, model_random_state=32523423, # sample_seed=5435, n_classes=2, num_att=10, num_drift_centroids=50) t = OneHotToCategorical([[10, 11, 12, 13], [ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 ]]) t2 = OneHotToCategorical([[10, 11, 12, 13], [ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 ]]) knn = KNNADWINClassifier(n_neighbors=8, leaf_size=40, max_window_size=2000) # pipe = Pipeline([('one_hot_to_categorical', t), ('KNNClassifier', knn)]) compare = KNeighborsClassifier(n_neighbors=8, algorithm='kd_tree', leaf_size=40, metric='euclidean') # pipe2 = Pipeline([('one_hot_to_categorical', t2), ('KNNClassifier', compare)]) first = True train = 200 if train > 0: X, y = stream.next_sample(train) # pipe.partial_fit(X, y, classes=stream.target_values) # pipe.partial_fit(X, y, classes=stream.target_values) # pipe2.fit(X, y) knn.partial_fit(X, y, classes=stream.target_values) compare.fit(X, y) first = False n_samples = 0 max_samples = 10000 my_corrects = 0 compare_corrects = 0 while n_samples < max_samples: if n_samples % (max_samples / 20) == 0: logging.info('%s%%', str((n_samples // (max_samples / 20) * 5))) X, y = stream.next_sample() # my_pred = pipe.predict(X) my_pred = knn.predict(X) # my_pred = [1] if first: # pipe.partial_fit(X, y, classes=stream.target_values) # pipe.partial_fit(X, y, classes=stream.target_values) knn.partial_fit(X, y, classes=stream.target_values) first = False else: # pipe.partial_fit(X, y) knn.partial_fit(X, y) # compare_pred = pipe2.predict(X) compare_pred = compare.predict(X) if y[0] == my_pred[0]: my_corrects += 1 if y[0] == compare_pred[0]: compare_corrects += 1 n_samples += 1 end = timer() print('Evaluation time: ' + str(end - start)) print(str(n_samples) + ' samples analyzed.') print('My performance: ' + str(my_corrects / n_samples)) print('Compare performance: ' + str(compare_corrects / n_samples))