From 74216834e6ef213c2a862c0df4f9a8928f227006 Mon Sep 17 00:00:00 2001 From: Devindi97 Date: Tue, 12 Aug 2025 16:19:50 +0200 Subject: [PATCH 1/2] New wrapper for anomaly detectors Fixes #31 --- .../wrappers/changedetectors/__init__.py | 1 + .../wrappers/changedetectors/basics.py | 199 ++++++++++++++++++ ...d_ad_001_point_anomaly_detection_hst_1d.py | 158 ++++++++++++++ ...d_ad_002_point_anomaly_detection_hst_2d.py | 158 ++++++++++++++ ..._ad_003_point_anomaly_detection__hst_3d.py | 158 ++++++++++++++ ...ad_004_point_anomaly_detection_ocsvm_1d.py | 165 +++++++++++++++ ...ad_005_point_anomaly_detection_ocsvm_2d.py | 164 +++++++++++++++ ...ad_006_point_anomaly_detection_ocsvm_3d.py | 164 +++++++++++++++ ...cd_ad_007_point_anomaly_detection_gs_1d.py | 146 +++++++++++++ ...cd_ad_008_point_anomaly_detection_gs_2d.py | 146 +++++++++++++ ...cd_ad_009_point_anomaly_detection_gs_3d.py | 146 +++++++++++++ ...d_ad_010_point_anomaly_detection_lof_1d.py | 144 +++++++++++++ ...d_ad_011_point_anomaly_detection_lof_2d.py | 144 +++++++++++++ ...d_ad_012_point_anomaly_detection_lof_3d.py | 144 +++++++++++++ ...d_ad_013_point_anomaly_detection_pad_1d.py | 154 ++++++++++++++ ...d_ad_014_point_anomaly_detection_pad_2d.py | 154 ++++++++++++++ ...d_ad_015_point_anomaly_detection_pad_3d.py | 154 ++++++++++++++ ...o_oa_cd_dd_001_drift_detection_adwin_1d.py | 167 +++++++++++++++ ...o_oa_cd_dd_002_drift_detection_adwin_2d.py | 167 +++++++++++++++ ...o_oa_cd_dd_003_drift_detection_adwin_3d.py | 167 +++++++++++++++ ...o_oa_cd_dd_004_drift_detection_kswin_1d.py | 161 ++++++++++++++ ...o_oa_cd_dd_005_drift_detection_kswin_2d.py | 161 ++++++++++++++ ...o_oa_cd_dd_006_drift_detection_kswin_3d.py | 161 ++++++++++++++ 23 files changed, 3483 insertions(+) create mode 100644 src/mlpro_int_river/wrappers/changedetectors/__init__.py create mode 100644 src/mlpro_int_river/wrappers/changedetectors/basics.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_001_point_anomaly_detection_hst_1d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_002_point_anomaly_detection_hst_2d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_003_point_anomaly_detection__hst_3d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_004_point_anomaly_detection_ocsvm_1d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_005_point_anomaly_detection_ocsvm_2d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_006_point_anomaly_detection_ocsvm_3d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_007_point_anomaly_detection_gs_1d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_008_point_anomaly_detection_gs_2d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_009_point_anomaly_detection_gs_3d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_010_point_anomaly_detection_lof_1d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_011_point_anomaly_detection_lof_2d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_012_point_anomaly_detection_lof_3d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_001_drift_detection_adwin_1d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_002_drift_detection_adwin_2d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_003_drift_detection_adwin_3d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_004_drift_detection_kswin_1d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_005_drift_detection_kswin_2d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_006_drift_detection_kswin_3d.py diff --git a/src/mlpro_int_river/wrappers/changedetectors/__init__.py b/src/mlpro_int_river/wrappers/changedetectors/__init__.py new file mode 100644 index 0000000..e682b66 --- /dev/null +++ b/src/mlpro_int_river/wrappers/changedetectors/__init__.py @@ -0,0 +1 @@ +from .basics import * \ No newline at end of file diff --git a/src/mlpro_int_river/wrappers/changedetectors/basics.py b/src/mlpro_int_river/wrappers/changedetectors/basics.py new file mode 100644 index 0000000..86e2d5b --- /dev/null +++ b/src/mlpro_int_river/wrappers/changedetectors/basics.py @@ -0,0 +1,199 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river.wrappers.changedetectors +## -- Module : basics.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +This module provides wrapper root classes from River to MLPro, specifically for anomaly detectors. + +Learn more: +https://www.riverml.xyz/ + +""" + +import numpy as np +from river.anomaly.base import AnomalyDetector as ADRiver +from river.base import DriftDetector as DDRiver + +from mlpro.bf import Log, ParamError +from mlpro.bf.streams import StreamTask, Instance +from mlpro.oa.streams.tasks.changedetectors.anomalydetectors.instancebased import AnomalyDetectorIBPG +from mlpro.oa.streams.tasks.changedetectors.driftdetectors.instancebased import DriftDetectorIB +from mlpro.oa.streams.tasks.changedetectors.anomalydetectors.anomalies.instancebased import PointAnomaly +from mlpro.oa.streams.tasks.changedetectors.driftdetectors.clusterbased.generic import DriftDetectorCBGenSingleGradient +from mlpro_int_river.wrappers import WrapperRiver + + + +# Export list for public API +__all__ = [ 'WrAnomalyDetectorRiver2MLPro', + 'WrDriftDetectorRiver2MLPro' ] + + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +class WrAnomalyDetectorRiver2MLPro (AnomalyDetectorIBPG, WrapperRiver): + + C_TYPE = 'Anomaly Detector (river)' + +## ------------------------------------------------------------------------------------------------- + def __init__(self, + p_algo_river : ADRiver, + p_range_max=StreamTask.C_RANGE_THREAD, + p_ada = True, p_duplicate_data = False, + p_visualize = False, + p_logging=Log.C_LOG_ALL, + p_anomaly_buffer_size = 100, + p_thrs_inst = 0, + p_group_anomaly_det = True, + p_instance_buffer_size : int = 20, + p_detection_steprate : int = 1, + **p_kwargs): + + WrapperRiver.__init__( self, p_logging = p_logging ) + + AnomalyDetectorIBPG.__init__( self, + p_group_anomaly_det = p_group_anomaly_det, + p_name = type(p_algo_river).__name__, + p_range_max = p_range_max, + p_ada = True, + p_duplicate_data = p_duplicate_data, + p_visualize = p_visualize, + p_logging = p_logging, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_thrs_inst = 1, + **p_kwargs ) + + if ( p_detection_steprate > p_instance_buffer_size ) or ( p_detection_steprate < 1 ): + raise ParamError('Please set the parameter "p_detection_steprate" >= 1 and <= "p_instance_buffer_size"') + + self._algo_river = p_algo_river + self._inst_buffer_size = p_instance_buffer_size + self._detection_steprate = p_detection_steprate + self._inst_counter = 0 + + self._inst_data_buffer : np.ndarray = None + self._inst_data_buffer_full : bool = False + self._inst_ref_buffer : np.ndarray = np.empty(self._inst_buffer_size, dtype = object) + + self._inst_buffer_pos : int = 0 + + self._block_mode = ( self._detection_steprate == self._inst_buffer_size ) + + +## ------------------------------------------------------------------------------------------------- + def _detect(self, p_instance : Instance, **p_kwargs): + + + feature_data = p_instance.get_feature_data() + feature_values = feature_data.get_values() + num_features = feature_data.get_related_set().get_num_dim() + feature_names = feature_data.get_dim_ids() + + instance_dict = dict(zip(feature_names, feature_values)) + score = self._algo_river.score_one(instance_dict) + + if score > 0.8: + anomaly = PointAnomaly( p_status=True, + p_tstamp=p_instance.tstamp, + p_visualize=self.get_visualization(), + p_raising_object=self, + p_instances=[p_instance]) + + self._raise_anomaly_event(p_anomaly=anomaly, p_instance=p_instance) + + self._algo_river.learn_one(instance_dict) + + + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +class WrDriftDetectorRiver2MLPro (DriftDetectorIB, WrapperRiver): + + C_TYPE = 'Drift Detector (river)' + +## ------------------------------------------------------------------------------------------------- + def __init__(self, + p_algo_river : DDRiver, + p_range_max=StreamTask.C_RANGE_THREAD, + p_ada = True, + p_duplicate_data = False, + p_visualize = False, + p_logging=Log.C_LOG_ALL, + p_drift_buffer_size = 100, + p_thrs_inst = 0, + p_instance_buffer_size : int = 20, + p_detection_steprate : int = 1, + p_feature_idx=0, + p_feature_id=None, + **p_kwargs): + + WrapperRiver.__init__( self, p_logging = p_logging ) + + DriftDetectorIB.__init__( self, + p_name = type(p_algo_river).__name__, + p_range_max = p_range_max, + p_ada = True, + p_duplicate_data = p_duplicate_data, + p_visualize = p_visualize, + p_logging = p_logging, + p_drift_buffer_size = p_drift_buffer_size, + p_thrs_inst = 1, + **p_kwargs ) + + if ( p_detection_steprate > p_instance_buffer_size ) or ( p_detection_steprate < 1 ): + raise ParamError('Please set the parameter "p_detection_steprate" >= 1 and <= "p_instance_buffer_size"') + + self._algo_river = p_algo_river + self._feature_idx = p_feature_idx + self._feature_id = p_feature_id + self._inst_buffer_size = p_instance_buffer_size + self._detection_steprate = p_detection_steprate + self._inst_counter = 0 + + self._inst_data_buffer : np.ndarray = None + self._inst_data_buffer_full : bool = False + self._inst_ref_buffer : np.ndarray = np.empty(self._inst_buffer_size, dtype = object) + + self._inst_buffer_pos : int = 0 + + self._block_mode = ( self._detection_steprate == self._inst_buffer_size ) + + +## ------------------------------------------------------------------------------------------------- + def _detect(self, p_instance : Instance, **p_kwargs): + + # Get input feature vector + feature_data = p_instance.get_feature_data() + + # Determine feature value to monitor + if self._feature_id is not None: + value = feature_data.get_value(self._feature_id) + else: + value = feature_data.get_values()[self._feature_idx] + + # Feed value into River drift detector + self._algo_river.update(value) + + if self._algo_river.drift_detected: + drift = DriftDetectorCBGenSingleGradient( + p_status=True, + p_tstamp=p_instance.tstamp, + p_visualize=self.get_visualization(), + p_raising_object=self, + p_instances=[p_instance] + ) + + self._raise_drift_event(p_drift=drift, p_instance=p_instance) + diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_001_point_anomaly_detection_hst_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_001_point_anomaly_detection_hst_1d.py new file mode 100644 index 0000000..6c8f647 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_001_point_anomaly_detection_hst_1d.py @@ -0,0 +1,158 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_001_point_anomaly_detection_hst_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import HalfSpaceTrees +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioHST1D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with Half Space Trees 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_n_trees: int = 10, + p_height: int = 8, + p_window_size: int = 250, + p_seed: int = 20, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'HalfSpaceTrees' anomaly detector + river_hst = HalfSpaceTrees( n_trees = p_n_trees, + height = p_height, + window_size = p_window_size, + seed = p_seed ) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_hst, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + n_trees = 10 + height = 8 + window_size = 250 + seed = 20 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + n_trees = int(input(f'Algo HST: Number of trees to use (press ENTER for {n_trees}): ') or n_trees) + height = int(input(f'Algo HST: Height if each tree (press ENTER for {height}): ') or height) + window_size = int(input(f'Algo HST: Number of observations (press ENTER for {window_size}): ') or window_size) + seed = int(input(f'Algo HST: Seed number (press ENTER for {seed}): ') or seed) + + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_trees = 10 + height = 8 + window_size = 250 + seed = 20 + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioHST1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_n_trees = n_trees, + p_height = height, + p_window_size = window_size, + p_seed = seed, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_002_point_anomaly_detection_hst_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_002_point_anomaly_detection_hst_2d.py new file mode 100644 index 0000000..34197c2 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_002_point_anomaly_detection_hst_2d.py @@ -0,0 +1,158 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_002_point_anomaly_detection_hst_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import HalfSpaceTrees +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioHST2D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with Half Space Trees 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_n_trees: int = 10, + p_height: int = 8, + p_window_size: int = 250, + p_seed: int = 20, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'HalfSpaceTrees' anomaly detector + river_hst = HalfSpaceTrees( n_trees = p_n_trees, + height = p_height, + window_size = p_window_size, + seed = p_seed ) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_hst, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + n_trees = 10 + height = 8 + window_size = 250 + seed = 20 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + n_trees = int(input(f'Algo HST: Number of trees to use (press ENTER for {n_trees}): ') or n_trees) + height = int(input(f'Algo HST: Height if each tree (press ENTER for {height}): ') or height) + window_size = int(input(f'Algo HST: Number of observations (press ENTER for {window_size}): ') or window_size) + seed = int(input(f'Algo HST: Seed number (press ENTER for {seed}): ') or seed) + + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_trees = 10 + height = 8 + window_size = 250 + seed = 20 + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioHST2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_n_trees = n_trees, + p_height = height, + p_window_size = window_size, + p_seed = seed, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_003_point_anomaly_detection__hst_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_003_point_anomaly_detection__hst_3d.py new file mode 100644 index 0000000..099ec81 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_003_point_anomaly_detection__hst_3d.py @@ -0,0 +1,158 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_003_point_anomaly_detection_hst_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import HalfSpaceTrees +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioHST3D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with Half Space Trees 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_n_trees: int = 10, + p_height: int = 8, + p_window_size: int = 250, + p_seed: int = 20, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'HalfSpaceTrees' anomaly detector + river_hst = HalfSpaceTrees( n_trees = p_n_trees, + height = p_height, + window_size = p_window_size, + seed = p_seed ) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_hst, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + n_trees = 10 + height = 8 + window_size = 250 + seed = 20 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + n_trees = int(input(f'Algo HST: Number of trees to use (press ENTER for {n_trees}): ') or n_trees) + height = int(input(f'Algo HST: Height if each tree (press ENTER for {height}): ') or height) + window_size = int(input(f'Algo HST: Number of observations (press ENTER for {window_size}): ') or window_size) + seed = int(input(f'Algo HST: Seed number (press ENTER for {seed}): ') or seed) + + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_trees = 10 + height = 8 + window_size = 250 + seed = 20 + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioHST3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_n_trees = n_trees, + p_height = height, + p_window_size = window_size, + p_seed = seed, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_004_point_anomaly_detection_ocsvm_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_004_point_anomaly_detection_ocsvm_1d.py new file mode 100644 index 0000000..4e14d3e --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_004_point_anomaly_detection_ocsvm_1d.py @@ -0,0 +1,165 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_004_point_anomaly_detection_ocsvm_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import OneClassSVM +from river import optim +from river.optim import SGD +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioOCSVM1D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with OneClassSVM 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_nu=0.1, + p_optimizer: optim.base.Optimizer | None = None, + p_intercept_lr: optim.base.Scheduler | float = 0.01, + p_clip_gradient=1e12, + p_initializer: optim.base.Initializer | None = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'OneClassSVM' anomaly detector + river_ocsvm = OneClassSVM( nu = p_nu, + optimizer= p_optimizer, + intercept_lr= p_intercept_lr, + clip_gradient= p_clip_gradient, + initializer=p_initializer ) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_ocsvm, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + nu = 0.1 + optimizer = None + intercept_lr = 0.01 + clip_gradient = 1e12 + initializer = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + nu = (input(f'Algo OCSVM: Nu (press ENTER for {nu}): ') or nu) + optimizer = optim.base.Optimizer(input(f'Algo OCSVM: The sequencial optimizer (press ENTER for {optimizer}): ') or optimizer) + intercept_lr = optim.base.Optimizer(input(f'Algo OCSVM: Learning rate scheduler (press ENTER for {intercept_lr}): ') or intercept_lr) + clip_gradient = (input(f'Algo OCSVM: Clip gradient (press ENTER for {clip_gradient}): ') or clip_gradient) + initializer = optim.base.Optimizer(input(f'Algo OCSVM: Weights initialization scheme (press ENTER for {initializer}): ') or initializer) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + nu = 0.1 + optimizer = None + intercept_lr = 0.01 + clip_gradient = 1e12 + initializer = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioOCSVM1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_nu = nu, + p_optimizer = optimizer, + p_intercept_lr = intercept_lr, + p_clip_gradient = clip_gradient, + p_initializer = initializer, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_005_point_anomaly_detection_ocsvm_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_005_point_anomaly_detection_ocsvm_2d.py new file mode 100644 index 0000000..22a3815 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_005_point_anomaly_detection_ocsvm_2d.py @@ -0,0 +1,164 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_005_point_anomaly_detection_ocsvm_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import OneClassSVM +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioOCSVM2D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with OneClassSVM 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_nu=0.1, + p_optimizer: optim.base.Optimizer | None = None, + p_intercept_lr: optim.base.Scheduler | float = 0.01, + p_clip_gradient=1e12, + p_initializer: optim.base.Initializer | None = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'OneClassSVM' anomaly detector + river_ocsvm = OneClassSVM( nu = p_nu, + optimizer= p_optimizer, + intercept_lr= p_intercept_lr, + clip_gradient= p_clip_gradient, + initializer=p_initializer ) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_ocsvm, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + nu = 0.1 + optimizer = None + intercept_lr = 0.01 + clip_gradient = 1e12 + initializer = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + nu = (input(f'Algo OCSVM: Nu (press ENTER for {nu}): ') or nu) + optimizer = optim.base.Optimizer(input(f'Algo OCSVM: The sequencial optimizer (press ENTER for {optimizer}): ') or optimizer) + intercept_lr = optim.base.Optimizer(input(f'Algo OCSVM: Learning rate scheduler (press ENTER for {intercept_lr}): ') or intercept_lr) + clip_gradient = (input(f'Algo OCSVM: Clip gradient (press ENTER for {clip_gradient}): ') or clip_gradient) + initializer = optim.base.Optimizer(input(f'Algo OCSVM: Weights initialization scheme (press ENTER for {initializer}): ') or initializer) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + nu = 0.1 + optimizer = None + intercept_lr = 0.01 + clip_gradient = 1e12 + initializer = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioOCSVM2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_nu = nu, + p_optimizer = optimizer, + p_intercept_lr = intercept_lr, + p_clip_gradient = clip_gradient, + p_initializer = initializer, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_006_point_anomaly_detection_ocsvm_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_006_point_anomaly_detection_ocsvm_3d.py new file mode 100644 index 0000000..cefee5c --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_006_point_anomaly_detection_ocsvm_3d.py @@ -0,0 +1,164 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_006_point_anomaly_detection_ocsvm_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import OneClassSVM +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioOCSVM3D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with OneClassSVM 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_nu=0.1, + p_optimizer: optim.base.Optimizer | None = None, + p_intercept_lr: optim.base.Scheduler | float = 0.01, + p_clip_gradient=1e12, + p_initializer: optim.base.Initializer | None = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'OneClassSVM' anomaly detector + river_ocsvm = OneClassSVM( nu = p_nu, + optimizer= p_optimizer, + intercept_lr= p_intercept_lr, + clip_gradient= p_clip_gradient, + initializer=p_initializer ) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_ocsvm, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + nu = 0.1 + optimizer = None + intercept_lr = 0.01 + clip_gradient = 1e12 + initializer = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + nu = (input(f'Algo OCSVM: Nu (press ENTER for {nu}): ') or nu) + optimizer = optim.base.Optimizer(input(f'Algo OCSVM: The sequencial optimizer (press ENTER for {optimizer}): ') or optimizer) + intercept_lr = optim.base.Optimizer(input(f'Algo OCSVM: Learning rate scheduler (press ENTER for {intercept_lr}): ') or intercept_lr) + clip_gradient = (input(f'Algo OCSVM: Clip gradient (press ENTER for {clip_gradient}): ') or clip_gradient) + initializer = optim.base.Optimizer(input(f'Algo OCSVM: Weights initialization scheme (press ENTER for {initializer}): ') or initializer) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + nu = 0.1 + optimizer = None + intercept_lr = 0.01 + clip_gradient = 1e12 + initializer = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioOCSVM3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_nu = nu, + p_optimizer = optimizer, + p_intercept_lr = intercept_lr, + p_clip_gradient = clip_gradient, + p_initializer = initializer, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_007_point_anomaly_detection_gs_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_007_point_anomaly_detection_gs_1d.py new file mode 100644 index 0000000..5600cb7 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_007_point_anomaly_detection_gs_1d.py @@ -0,0 +1,146 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_007_point_anomaly_detection_gs_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import GaussianScorer +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioGS1D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with GaussianScorer 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_window_size = None, + p_grace_period: int = 100, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'GaussianScorer' anomaly detector + river_gs = GaussianScorer( window_size = p_window_size, + grace_period = p_grace_period) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_gs, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + window_size = None + grace_period = 100 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + window_size = (input(f'Algo GS: Window size (press ENTER for {window_size}): ') or window_size) + grace_period = int(input(f'Algo GS: Grace period (press ENTER for {grace_period}): ') or grace_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + window_size = None + grace_period = 100 + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioGS1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_window_size = window_size, + p_grace_period =grace_period, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_008_point_anomaly_detection_gs_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_008_point_anomaly_detection_gs_2d.py new file mode 100644 index 0000000..8ff60cc --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_008_point_anomaly_detection_gs_2d.py @@ -0,0 +1,146 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_008_point_anomaly_detection_gs_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import GaussianScorer +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioGS2D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with GaussianScorer 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_window_size = None, + p_grace_period: int = 100, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'GaussianScorer' anomaly detector + river_gs = GaussianScorer( window_size = p_window_size, + grace_period = p_grace_period) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_gs, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + window_size = None + grace_period = 100 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + window_size = (input(f'Algo GS: Window size (press ENTER for {window_size}): ') or window_size) + grace_period = int(input(f'Algo GS: Grace period (press ENTER for {grace_period}): ') or grace_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + window_size = None + grace_period = 100 + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioGS2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_window_size = window_size, + p_grace_period =grace_period, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_009_point_anomaly_detection_gs_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_009_point_anomaly_detection_gs_3d.py new file mode 100644 index 0000000..1514c5e --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_009_point_anomaly_detection_gs_3d.py @@ -0,0 +1,146 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_009_point_anomaly_detection_gs_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import GaussianScorer +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioGS3D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with GaussianScorer 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_window_size = None, + p_grace_period: int = 100, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + p_thrs_inst: int = 5, + p_thrs_clusters: int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'GaussianScorer' anomaly detector + river_gs = GaussianScorer( window_size = p_window_size, + grace_period = p_grace_period) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_gs, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + window_size = None + grace_period = 100 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + window_size = (input(f'Algo GS: Window size (press ENTER for {window_size}): ') or window_size) + grace_period = int(input(f'Algo GS: Grace period (press ENTER for {grace_period}): ') or grace_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + window_size = None + grace_period = 100 + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioGS3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_window_size = window_size, + p_grace_period =grace_period, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_010_point_anomaly_detection_lof_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_010_point_anomaly_detection_lof_1d.py new file mode 100644 index 0000000..2d0a26a --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_010_point_anomaly_detection_lof_1d.py @@ -0,0 +1,144 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_010_point_anomaly_detection_lof_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import LocalOutlierFactor +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioLOF1D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with LocalOutlierFactor 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_n_neighbors: int = 10, + p_distance_func = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_lof = LocalOutlierFactor( n_neighbors = p_n_neighbors, + distance_func = p_distance_func) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_lof, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + n_neighbors = int(input(f'Algo LOF: Number of Neighbors (press ENTER for {n_neighbors}): ') or n_neighbors) + distance_func = (input(f'Algo LOF: Distance Function (press ENTER for {distance_func}): ') or distance_func) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioLOF1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_n_neighbors = n_neighbors, + p_distance_func =distance_func, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_011_point_anomaly_detection_lof_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_011_point_anomaly_detection_lof_2d.py new file mode 100644 index 0000000..103b5df --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_011_point_anomaly_detection_lof_2d.py @@ -0,0 +1,144 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_011_point_anomaly_detection_lof_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import LocalOutlierFactor +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioLOF2D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with LocalOutlierFactor 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_n_neighbors: int = 10, + p_distance_func = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_lof = LocalOutlierFactor( n_neighbors = p_n_neighbors, + distance_func = p_distance_func) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_lof, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + n_neighbors = int(input(f'Algo LOF: Number of Neighbors (press ENTER for {n_neighbors}): ') or n_neighbors) + distance_func = (input(f'Algo LOF: Distance Function (press ENTER for {distance_func}): ') or distance_func) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioLOF2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_n_neighbors = n_neighbors, + p_distance_func =distance_func, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_012_point_anomaly_detection_lof_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_012_point_anomaly_detection_lof_3d.py new file mode 100644 index 0000000..df6eae4 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_012_point_anomaly_detection_lof_3d.py @@ -0,0 +1,144 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_012_point_anomaly_detection_lof_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import LocalOutlierFactor +from river import optim +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioLOF3D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with LocalOutlierFactor 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_n_neighbors: int = 10, + p_distance_func = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_lof = LocalOutlierFactor( n_neighbors = p_n_neighbors, + distance_func = p_distance_func) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_lof, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + n_neighbors = int(input(f'Algo LOF: Number of Neighbors (press ENTER for {n_neighbors}): ') or n_neighbors) + distance_func = (input(f'Algo LOF: Distance Function (press ENTER for {distance_func}): ') or distance_func) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioLOF3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_n_neighbors = n_neighbors, + p_distance_func =distance_func, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py new file mode 100644 index 0000000..e5ef82d --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py @@ -0,0 +1,154 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import PredictiveAnomalyDetection +from river import optim,base +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioPAD1D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with PredictiveAnomalyDetection 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_predictive_model: base.Estimator|None = None, + p_horizon: int = 1, + p_n_std: float = 3.0, + p_warmup_period: int = 0, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_pad = PredictiveAnomalyDetection( predictive_model = p_predictive_model, + horizon = p_horizon, + n_std = p_n_std, + warmup_period = p_warmup_period) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_pad, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + predictive_model = None + horizon = 1 + n_std = 3.0 + warmup_period = 0 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + predictive_model = (input(f'Algo PAD: Predictive model (press ENTER for {predictive_model}): ') or predictive_model) + horizon = int(input(f'Algo PAD: Horizon (press ENTER for {horizon}): ') or horizon) + n_std = float(input(f'Algo PAD: Number of Standard Deviations (press ENTER for {n_std}): ') or n_std) + warmup_period = int(input(f'Algo PAD: Warmup period (press ENTER for {warmup_period}): ') or warmup_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioPAD1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_predictive_model = predictive_model, + p_horizon = horizon, + p_n_std = n_std, + p_warmup_period = warmup_period, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py new file mode 100644 index 0000000..d2b8004 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py @@ -0,0 +1,154 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import PredictiveAnomalyDetection +from river import optim,base +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioPAD2D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with PredictiveAnomalyDetection 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_predictive_model: base.Estimator|None = None, + p_horizon: int = 1, + p_n_std: float = 3.0, + p_warmup_period: int = 0, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_pad = PredictiveAnomalyDetection( predictive_model = p_predictive_model, + horizon = p_horizon, + n_std = p_n_std, + warmup_period = p_warmup_period) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_pad, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + predictive_model = None + horizon = 1 + n_std = 3.0 + warmup_period = 0 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + predictive_model = (input(f'Algo PAD: Predictive model (press ENTER for {predictive_model}): ') or predictive_model) + horizon = int(input(f'Algo PAD: Horizon (press ENTER for {horizon}): ') or horizon) + n_std = float(input(f'Algo PAD: Number of Standard Deviations (press ENTER for {n_std}): ') or n_std) + warmup_period = int(input(f'Algo PAD: Warmup period (press ENTER for {warmup_period}): ') or warmup_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioPAD2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_predictive_model = predictive_model, + p_horizon = horizon, + p_n_std = n_std, + p_warmup_period = warmup_period, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py new file mode 100644 index 0000000..058e41d --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py @@ -0,0 +1,154 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" +from river.anomaly import PredictiveAnomalyDetection +from river import optim,base +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioPAD3D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with PredictiveAnomalyDetection 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_predictive_model: base.Estimator|None = None, + p_horizon: int = 1, + p_n_std: float = 3.0, + p_warmup_period: int = 0, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_pad = PredictiveAnomalyDetection( predictive_model = p_predictive_model, + horizon = p_horizon, + n_std = p_n_std, + warmup_period = p_warmup_period) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_pad, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + predictive_model = None + horizon = 1 + n_std = 3.0 + warmup_period = 0 + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + predictive_model = (input(f'Algo PAD: Predictive model (press ENTER for {predictive_model}): ') or predictive_model) + horizon = int(input(f'Algo PAD: Horizon (press ENTER for {horizon}): ') or horizon) + n_std = float(input(f'Algo PAD: Number of Standard Deviations (press ENTER for {n_std}): ') or n_std) + warmup_period = int(input(f'Algo PAD: Warmup period (press ENTER for {warmup_period}): ') or warmup_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + n_neighbors = 10 + distance_func = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioPAD3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_predictive_model = predictive_model, + p_horizon = horizon, + p_n_std = n_std, + p_warmup_period = warmup_period, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_001_drift_detection_adwin_1d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_001_drift_detection_adwin_1d.py new file mode 100644 index 0000000..5d70ab2 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_001_drift_detection_adwin_1d.py @@ -0,0 +1,167 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_001_drift_detection_adwin_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" + +from sparccstream import * +from river.drift import ADWIN +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioADWIN1D (OAStreamScenario): + + C_NAME = 'Drift Detection with ADWIN 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_delta: float = 0.022, + p_clock: int = 32, + p_max_buckets: int = 5, + p_min_window_length: int = 5, + p_grace_period: int = 10, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 1, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'ADWIN' drift detector + river_adwin = ADWIN( delta = p_delta, + clock = p_clock, + max_buckets = p_max_buckets, + min_window_length = p_min_window_length, + grace_period = p_grace_period ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_adwin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + delta = 0.022 + clock = 32 + max_buckets = 5 + min_window_length = 5 + grace_period = 10 + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + delta = float(input(f'Algo adwin: Significance value (press ENTER for {delta}): ') or delta) + clock = int(input(f'Algo adwin: Clock (press ENTER for {clock}): ') or clock) + max_buckets = int(input(f'Algo adwin: Maximum number of buckets (press ENTER for {max_buckets}): ') or max_buckets) + min_window_length = int(input(f'Algo adwin: Minimum length of a window (press ENTER for {min_window_length}): ') or min_window_length) + grace_period = int(input(f'Algo adwin: Grace period (press ENTER for {grace_period}): ') or grace_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + delta = 0.022 + clock = 32 + max_buckets = 5 + min_window_length = 5 + grace_period = 10 + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioADWIN1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_delta = delta, + p_clock = clock, + p_max_buckets = max_buckets, + p_min_window_length = min_window_length, + p_grace_period = grace_period, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_002_drift_detection_adwin_2d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_002_drift_detection_adwin_2d.py new file mode 100644 index 0000000..230996a --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_002_drift_detection_adwin_2d.py @@ -0,0 +1,167 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_002_drift_detection_adwin_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" + +from sparccstream import * +from river.drift import ADWIN +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioADWIN2D (OAStreamScenario): + + C_NAME = 'Drift Detection with ADWIN 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_delta: float = 0.022, + p_clock: int = 32, + p_max_buckets: int = 5, + p_min_window_length: int = 5, + p_grace_period: int = 10, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 2, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'ADWIN' drift detector + river_adwin = ADWIN( delta = p_delta, + clock = p_clock, + max_buckets = p_max_buckets, + min_window_length = p_min_window_length, + grace_period = p_grace_period ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_adwin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + delta = 0.022 + clock = 32 + max_buckets = 5 + min_window_length = 5 + grace_period = 10 + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + delta = float(input(f'Algo adwin: Significance value (press ENTER for {delta}): ') or delta) + clock = int(input(f'Algo adwin: Clock (press ENTER for {clock}): ') or clock) + max_buckets = int(input(f'Algo adwin: Maximum number of buckets (press ENTER for {max_buckets}): ') or max_buckets) + min_window_length = int(input(f'Algo adwin: Minimum length of a window (press ENTER for {min_window_length}): ') or min_window_length) + grace_period = int(input(f'Algo adwin: Grace period (press ENTER for {grace_period}): ') or grace_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + delta = 0.022 + clock = 32 + max_buckets = 5 + min_window_length = 5 + grace_period = 10 + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioADWIN2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_delta = delta, + p_clock = clock, + p_max_buckets = max_buckets, + p_min_window_length = min_window_length, + p_grace_period = grace_period, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_003_drift_detection_adwin_3d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_003_drift_detection_adwin_3d.py new file mode 100644 index 0000000..427a03c --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_003_drift_detection_adwin_3d.py @@ -0,0 +1,167 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_003_drift_detection_adwin_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" + +from sparccstream import * +from river.drift import ADWIN +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioADWIN3D (OAStreamScenario): + + C_NAME = 'Drift Detection with ADWIN 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_delta: float = 0.022, + p_clock: int = 32, + p_max_buckets: int = 5, + p_min_window_length: int = 5, + p_grace_period: int = 10, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 3, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'ADWIN' drift detector + river_adwin = ADWIN( delta = p_delta, + clock = p_clock, + max_buckets = p_max_buckets, + min_window_length = p_min_window_length, + grace_period = p_grace_period ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_adwin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + delta = 0.022 + clock = 32 + max_buckets = 5 + min_window_length = 5 + grace_period = 10 + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + delta = float(input(f'Algo adwin: Significance value (press ENTER for {delta}): ') or delta) + clock = int(input(f'Algo adwin: Clock (press ENTER for {clock}): ') or clock) + max_buckets = int(input(f'Algo adwin: Maximum number of buckets (press ENTER for {max_buckets}): ') or max_buckets) + min_window_length = int(input(f'Algo adwin: Minimum length of a window (press ENTER for {min_window_length}): ') or min_window_length) + grace_period = int(input(f'Algo adwin: Grace period (press ENTER for {grace_period}): ') or grace_period) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + delta = 0.022 + clock = 32 + max_buckets = 5 + min_window_length = 5 + grace_period = 10 + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioADWIN3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_delta = delta, + p_clock = clock, + p_max_buckets = max_buckets, + p_min_window_length = min_window_length, + p_grace_period = grace_period, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_004_drift_detection_kswin_1d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_004_drift_detection_kswin_1d.py new file mode 100644 index 0000000..ad1794c --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_004_drift_detection_kswin_1d.py @@ -0,0 +1,161 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_004_drift_detection_kswin_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" + +from sparccstream import * +from river.drift import KSWIN +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioKSWIN1D (OAStreamScenario): + + C_NAME = 'Drift Detection with KSWIN 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_alpha: float = 0.005, + p_window_size: int = 100, + p_stat_size: int = 30, + p_window = None, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 1, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'KSWIN' drift detector + river_kswin = KSWIN( alpha= p_alpha, + window_size= p_window_size, + stat_size = p_stat_size, + window = p_window ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + alpha = 0.005 + window_size = 100 + stat_size = 30 + window = None + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + alpha = float(input(f'Algo kswin: alpha (press ENTER for {alpha}): ') or alpha) + window_size = int(input(f'Algo kswin: Size of the sliding window (press ENTER for {window_size}): ') or window_size) + stat_size = int(input(f'Algo kswin: Size of the statistic window (press ENTER for {stat_size}): ') or stat_size) + window = (input(f'Algo kswin: Window (press ENTER for {window}): ') or window) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + alpha = 0.005 + window_size = 100 + stat_size = 30 + window = None + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioKSWIN1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_alpha = alpha, + p_window_size = window_size, + p_stat_size = stat_size, + p_window = window, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_005_drift_detection_kswin_2d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_005_drift_detection_kswin_2d.py new file mode 100644 index 0000000..bb05307 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_005_drift_detection_kswin_2d.py @@ -0,0 +1,161 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_005_drift_detection_kswin_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" + +from sparccstream import * +from river.drift import KSWIN +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioKSWIN2D (OAStreamScenario): + + C_NAME = 'Drift Detection with KSWIN 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_alpha: float = 0.005, + p_window_size: int = 100, + p_stat_size: int = 30, + p_window = None, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 2, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'KSWIN' drift detector + river_kswin = KSWIN( alpha= p_alpha, + window_size= p_window_size, + stat_size = p_stat_size, + window = p_window ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + alpha = 0.005 + window_size = 100 + stat_size = 30 + window = None + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + alpha = float(input(f'Algo kswin: alpha (press ENTER for {alpha}): ') or alpha) + window_size = int(input(f'Algo kswin: Size of the sliding window (press ENTER for {window_size}): ') or window_size) + stat_size = int(input(f'Algo kswin: Size of the statistic window (press ENTER for {stat_size}): ') or stat_size) + window = (input(f'Algo kswin: Window (press ENTER for {window}): ') or window) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + alpha = 0.005 + window_size = 100 + stat_size = 30 + window = None + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioKSWIN2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_alpha = alpha, + p_window_size = window_size, + p_stat_size = stat_size, + p_window = window, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_006_drift_detection_kswin_3d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_006_drift_detection_kswin_3d.py new file mode 100644 index 0000000..e18f188 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_006_drift_detection_kswin_3d.py @@ -0,0 +1,161 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_006_drift_detection_kswin_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-12 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-12) + +""" + +from sparccstream import * +from river.drift import KSWIN +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioKSWIN3D (OAStreamScenario): + + C_NAME = 'Drift Detection with KSWIN 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_alpha: float = 0.005, + p_window_size: int = 100, + p_stat_size: int = 30, + p_window = None, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 3, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'KSWIN' drift detector + river_kswin = KSWIN( alpha= p_alpha, + window_size= p_window_size, + stat_size = p_stat_size, + window = p_window ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + alpha = 0.005 + window_size = 100 + stat_size = 30 + window = None + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + alpha = float(input(f'Algo kswin: alpha (press ENTER for {alpha}): ') or alpha) + window_size = int(input(f'Algo kswin: Size of the sliding window (press ENTER for {window_size}): ') or window_size) + stat_size = int(input(f'Algo kswin: Size of the statistic window (press ENTER for {stat_size}): ') or stat_size) + window = (input(f'Algo kswin: Window (press ENTER for {window}): ') or window) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + alpha = 0.005 + window_size = 100 + stat_size = 30 + window = None + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioKSWIN3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_alpha = alpha, + p_window_size = window_size, + p_stat_size = stat_size, + p_window = window, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + From 74e24ebbc54f468ef6212271a1c87856236a88ba Mon Sep 17 00:00:00 2001 From: Devindi97 Date: Thu, 14 Aug 2025 13:06:33 +0200 Subject: [PATCH 2/2] New wrapper for drift detectors Fixes #45 --- ...d_ad_013_point_anomaly_detection_pad_1d.py | 2 +- ...d_ad_014_point_anomaly_detection_pad_2d.py | 2 +- ...d_ad_015_point_anomaly_detection_pad_3d.py | 2 +- ...d_ad_019_point_anomaly_detection_sad_1d.py | 138 ++++++++++++++ ...d_ad_020_point_anomaly_detection_sad_2d.py | 138 ++++++++++++++ ...d_ad_021_point_anomaly_detection_sad_3d.py | 138 ++++++++++++++ ...wto_oa_cd_dd_007_drift_detection_ddd_1d.py | 161 +++++++++++++++++ ...wto_oa_cd_dd_008_drift_detection_ddd_2d.py | 161 +++++++++++++++++ ...wto_oa_cd_dd_009_drift_detection_ddd_3d.py | 161 +++++++++++++++++ ...owto_oa_cd_dd_010_drift_detection_ph_1d.py | 168 ++++++++++++++++++ ...owto_oa_cd_dd_011_drift_detection_ph_2d.py | 168 ++++++++++++++++++ ...owto_oa_cd_dd_012_drift_detection_ph_3d.py | 168 ++++++++++++++++++ 12 files changed, 1404 insertions(+), 3 deletions(-) create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_019_point_anomaly_detection_sad_1d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_020_point_anomaly_detection_sad_2d.py create mode 100644 test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_021_point_anomaly_detection_sad_3d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_007_drift_detection_ddd_1d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_008_drift_detection_ddd_2d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_009_drift_detection_ddd_3d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_010_drift_detection_ph_1d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_011_drift_detection_ph_2d.py create mode 100644 test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_012_drift_detection_ph_3d.py diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py index e5ef82d..22af134 100644 --- a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_013_point_anomaly_detection_pad_1d.py @@ -56,7 +56,7 @@ def _setup(self, p_visualize=p_visualize, p_logging=p_logging ) - # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + # 3 Instantiation of River 'PredictiveAnomalyDetection' anomaly detector river_pad = PredictiveAnomalyDetection( predictive_model = p_predictive_model, horizon = p_horizon, n_std = p_n_std, diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py index d2b8004..078b15e 100644 --- a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_014_point_anomaly_detection_pad_2d.py @@ -56,7 +56,7 @@ def _setup(self, p_visualize=p_visualize, p_logging=p_logging ) - # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + # 3 Instantiation of River 'PredictiveAnomalyDetection' anomaly detector river_pad = PredictiveAnomalyDetection( predictive_model = p_predictive_model, horizon = p_horizon, n_std = p_n_std, diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py index 058e41d..924f46d 100644 --- a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_015_point_anomaly_detection_pad_3d.py @@ -56,7 +56,7 @@ def _setup(self, p_visualize=p_visualize, p_logging=p_logging ) - # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + # 3 Instantiation of River 'PredictiveAnomalyDetection' anomaly detector river_pad = PredictiveAnomalyDetection( predictive_model = p_predictive_model, horizon = p_horizon, n_std = p_n_std, diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_019_point_anomaly_detection_sad_1d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_019_point_anomaly_detection_sad_1d.py new file mode 100644 index 0000000..fdea934 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_019_point_anomaly_detection_sad_1d.py @@ -0,0 +1,138 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_019_point_anomaly_detection_sad_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-13 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-13) + +""" +from river.anomaly import StandardAbsoluteDeviation +from river import stats +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioSAD1D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with StandardAbsoluteDeviation 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_sub_stat: stats.base.Univariate|None = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_pad = StandardAbsoluteDeviation( sub_stat = p_sub_stat) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_pad, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + sub_stat = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + sub_stat = (input(f'Algo SAD: The statistic to be subtracted (press ENTER for {sub_stat}): ') or sub_stat) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + sub_stat = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioSAD1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_sub_stat = sub_stat, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_020_point_anomaly_detection_sad_2d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_020_point_anomaly_detection_sad_2d.py new file mode 100644 index 0000000..b247d92 --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_020_point_anomaly_detection_sad_2d.py @@ -0,0 +1,138 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_020_point_anomaly_detection_sad_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-13 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-13) + +""" +from river.anomaly import StandardAbsoluteDeviation +from river import stats +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioSAD2D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with StandardAbsoluteDeviation 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_sub_stat: stats.base.Univariate|None = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_pad = StandardAbsoluteDeviation( sub_stat = p_sub_stat) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_pad, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + sub_stat = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + sub_stat = (input(f'Algo SAD: The statistic to be subtracted (press ENTER for {sub_stat}): ') or sub_stat) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + sub_stat = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioSAD2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_sub_stat = sub_stat, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_021_point_anomaly_detection_sad_3d.py b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_021_point_anomaly_detection_sad_3d.py new file mode 100644 index 0000000..c3194ad --- /dev/null +++ b/test/howtos/oa/changedetection/anomalydetection/howto_oa_cd_ad_021_point_anomaly_detection_sad_3d.py @@ -0,0 +1,138 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_021_point_anomaly_detection_sad_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-13 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-13) + +""" +from river.anomaly import StandardAbsoluteDeviation +from river import stats +from mlpro_int_river.wrappers.changedetectors.basics import WrAnomalyDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.streams.streams import StreamMLProPOutliers +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class ADPAScenarioSAD3D (OAStreamScenario): + + C_NAME = 'Point Anomaly Detection with StandardAbsoluteDeviation 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_sub_stat: stats.base.Univariate|None = None, + p_anomaly_buffer_size: int = 100, + p_instance_buffer_size: int = 50, + p_detection_steprate: int = 50, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProPOutliers( p_functions = ['const', 'const', 'const'],#,'sin' , 'cos' , 'const'], + p_outlier_rate=0.02, + p_logging=p_logging, + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'LocalOutlierFactor' anomaly detector + river_pad = StandardAbsoluteDeviation( sub_stat = p_sub_stat) + + # 4 Creation of tasks and add them to the workflow + anomalydetector = WrAnomalyDetectorRiver2MLPro( p_algo_river = river_pad, + p_anomaly_buffer_size = p_anomaly_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_group_anomaly_det = False, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = anomalydetector) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + sub_stat = None + anomaly_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + sub_stat = (input(f'Algo SAD: The statistic to be subtracted (press ENTER for {sub_stat}): ') or sub_stat) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + sub_stat = None + anomaly_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = ADPAScenarioSAD3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_sub_stat = sub_stat, + p_anomaly_buffer_size = anomaly_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') \ No newline at end of file diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_007_drift_detection_ddd_1d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_007_drift_detection_ddd_1d.py new file mode 100644 index 0000000..1d9d84a --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_007_drift_detection_ddd_1d.py @@ -0,0 +1,161 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_007_drift_detection_ddd_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-14 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-14) + +""" + +from sparccstream import * +from river.drift import DummyDriftDetector +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioDDD1D (OAStreamScenario): + + C_NAME = 'Drift Detection with DummyDriftDetector 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_trigger_method: str = "fixed", + p_t_0: int = 300, + p_w: int = 0, + p_dynamic_cloning: bool = False, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 1, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'DummyDriftDetector' drift detector + river_kswin = DummyDriftDetector( trigger_method = p_trigger_method, + t_0 = p_t_0, + w = p_w, + dynamic_cloning = p_dynamic_cloning ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + trigger_method = "fixed" + t_0 = 300 + w = 0 + dynamic_cloning = False + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + trigger_method = str(input(f'Algo DDD: Thrigger method (press ENTER for {trigger_method}): ') or trigger_method) + t_0 = int(input(f'Algo DDD: Reference point to define triggers (press ENTER for {t_0}): ') or t_0) + w = int(input(f'Algo DDD: Auxiliary parameter (press ENTER for {w}): ') or w) + dynamic_cloning = bool(input(f'Algo DDD: Dynamic cloning (press ENTER for {dynamic_cloning}): ') or dynamic_cloning) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + trigger_method = "fixed" + t_0 = 300 + w = 0 + dynamic_cloning = False + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioDDD1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_trigger_method = trigger_method, + p_t_0 = t_0, + p_w = w, + p_dynamic_cloning = dynamic_cloning, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_008_drift_detection_ddd_2d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_008_drift_detection_ddd_2d.py new file mode 100644 index 0000000..91a9719 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_008_drift_detection_ddd_2d.py @@ -0,0 +1,161 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_008_drift_detection_ddd_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-14 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-14) + +""" + +from sparccstream import * +from river.drift import DummyDriftDetector +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioDDD2D (OAStreamScenario): + + C_NAME = 'Drift Detection with DummyDriftDetector 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_trigger_method: str = "fixed", + p_t_0: int = 300, + p_w: int = 0, + p_dynamic_cloning: bool = False, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 2, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'DummyDriftDetector' drift detector + river_kswin = DummyDriftDetector( trigger_method = p_trigger_method, + t_0 = p_t_0, + w = p_w, + dynamic_cloning = p_dynamic_cloning ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + trigger_method = "fixed" + t_0 = 300 + w = 0 + dynamic_cloning = False + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + trigger_method = str(input(f'Algo DDD: Thrigger method (press ENTER for {trigger_method}): ') or trigger_method) + t_0 = int(input(f'Algo DDD: Reference point to define triggers (press ENTER for {t_0}): ') or t_0) + w = int(input(f'Algo DDD: Auxiliary parameter (press ENTER for {w}): ') or w) + dynamic_cloning = bool(input(f'Algo DDD: Dynamic cloning (press ENTER for {dynamic_cloning}): ') or dynamic_cloning) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + trigger_method = "fixed" + t_0 = 300 + w = 0 + dynamic_cloning = False + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioDDD2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_trigger_method = trigger_method, + p_t_0 = t_0, + p_w = w, + p_dynamic_cloning = dynamic_cloning, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_009_drift_detection_ddd_3d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_009_drift_detection_ddd_3d.py new file mode 100644 index 0000000..d7ac891 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_009_drift_detection_ddd_3d.py @@ -0,0 +1,161 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_009_drift_detection_ddd_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-14 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-14) + +""" + +from sparccstream import * +from river.drift import DummyDriftDetector +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioDDD3D (OAStreamScenario): + + C_NAME = 'Drift Detection with DummyDriftDetector 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_trigger_method: str = "fixed", + p_t_0: int = 300, + p_w: int = 0, + p_dynamic_cloning: bool = False, + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 3, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'DummyDriftDetector' drift detector + river_kswin = DummyDriftDetector( trigger_method = p_trigger_method, + t_0 = p_t_0, + w = p_w, + dynamic_cloning = p_dynamic_cloning ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + trigger_method = "fixed" + t_0 = 300 + w = 0 + dynamic_cloning = False + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + trigger_method = str(input(f'Algo DDD: Thrigger method (press ENTER for {trigger_method}): ') or trigger_method) + t_0 = int(input(f'Algo DDD: Reference point to define triggers (press ENTER for {t_0}): ') or t_0) + w = int(input(f'Algo DDD: Auxiliary parameter (press ENTER for {w}): ') or w) + dynamic_cloning = bool(input(f'Algo DDD: Dynamic cloning (press ENTER for {dynamic_cloning}): ') or dynamic_cloning) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + trigger_method = "fixed" + t_0 = 300 + w = 0 + dynamic_cloning = False + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioDDD3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_trigger_method = trigger_method, + p_t_0 = t_0, + p_w = w, + p_dynamic_cloning = dynamic_cloning, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_010_drift_detection_ph_1d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_010_drift_detection_ph_1d.py new file mode 100644 index 0000000..d6bdd4a --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_010_drift_detection_ph_1d.py @@ -0,0 +1,168 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_010_drift_detection_ph_1d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-14 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-14) + +""" + +from sparccstream import * +from river.drift import PageHinkley +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioPH1D (OAStreamScenario): + + C_NAME = 'Drift Detection with PageHinkley 1D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_min_instances:int = 30, + p_delta: float = 0.005, + p_threshold: float = 50.0, + p_alpha: float = 0.9999, + *, + p_r_algo_mode: str = "both", + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 1, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'PageHinkley' drift detector + river_kswin = PageHinkley( min_instances = p_min_instances, + delta = p_delta, + threshold = p_threshold, + alpha = p_alpha, + mode = p_r_algo_mode ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + min_instances = 30 + delta = 0.05 + threshold = 50.0 + alpha = 0.9999 + r_algo_mode = "both" + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + min_instances = int(input(f'Algo PH: Minimum number of instances (press ENTER for {min_instances}): ') or min_instances) + delta = float(input(f'Algo PH: Delta (press ENTER for {delta}): ') or delta) + threshold = float(input(f'Algo PH: Change detection threshold (press ENTER for {threshold}): ') or threshold) + alpha = float(input(f'Algo PH: Alpha (press ENTER for {alpha}): ') or alpha) + r_algo_mode = str(input(f'Algo PH: Mode (press ENTER for {r_algo_mode}): ') or r_algo_mode) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + min_instances = 30 + delta = 0.05 + threshold = 50.0 + alpha = 0.9999 + r_algo_mode = "both" + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioPH1D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_min_instances = min_instances, + p_delta = delta, + p_threshold = threshold, + p_alpha = alpha, + p_r_algo_mode = r_algo_mode, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_011_drift_detection_ph_2d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_011_drift_detection_ph_2d.py new file mode 100644 index 0000000..c93c812 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_011_drift_detection_ph_2d.py @@ -0,0 +1,168 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_011_drift_detection_ph_2d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-14 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-14) + +""" + +from sparccstream import * +from river.drift import PageHinkley +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioPH2D (OAStreamScenario): + + C_NAME = 'Drift Detection with PageHinkley 2D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_min_instances:int = 30, + p_delta: float = 0.005, + p_threshold: float = 50.0, + p_alpha: float = 0.9999, + *, + p_r_algo_mode: str = "both", + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 2, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'PageHinkley' drift detector + river_kswin = PageHinkley( min_instances = p_min_instances, + delta = p_delta, + threshold = p_threshold, + alpha = p_alpha, + mode = p_r_algo_mode ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + min_instances = 30 + delta = 0.05 + threshold = 50.0 + alpha = 0.9999 + r_algo_mode = "both" + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + min_instances = int(input(f'Algo PH: Minimum number of instances (press ENTER for {min_instances}): ') or min_instances) + delta = float(input(f'Algo PH: Delta (press ENTER for {delta}): ') or delta) + threshold = float(input(f'Algo PH: Change detection threshold (press ENTER for {threshold}): ') or threshold) + alpha = float(input(f'Algo PH: Alpha (press ENTER for {alpha}): ') or alpha) + r_algo_mode = str(input(f'Algo PH: Mode (press ENTER for {r_algo_mode}): ') or r_algo_mode) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + min_instances = 30 + delta = 0.05 + threshold = 50.0 + alpha = 0.9999 + r_algo_mode = "both" + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioPH2D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_min_instances = min_instances, + p_delta = delta, + p_threshold = threshold, + p_alpha = alpha, + p_r_algo_mode = r_algo_mode, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') + diff --git a/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_012_drift_detection_ph_3d.py b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_012_drift_detection_ph_3d.py new file mode 100644 index 0000000..3c00211 --- /dev/null +++ b/test/howtos/oa/changedetection/driftdetection/howto_oa_cd_dd_012_drift_detection_ph_3d.py @@ -0,0 +1,168 @@ +## ------------------------------------------------------------------------------------------------- +## -- Project : MLPro - The integrative middleware framework for standardized machine learning +## -- Package : mlpro_int_river +## -- Module : howto_oa_cd_ad_012_drift_detection_ph_3d.py +## ------------------------------------------------------------------------------------------------- +## -- History : +## -- yyyy-mm-dd Ver. Auth. Description +## -- 2025-08-14 0.0.0 DS Creation +## ------------------------------------------------------------------------------------------------- + +""" +Ver. 0.0.0 (2025-08-14) + +""" + +from sparccstream import * +from river.drift import PageHinkley +from mlpro_int_river.wrappers.changedetectors.basics import WrDriftDetectorRiver2MLPro + +from mlpro.bf import * +from mlpro.bf.events import Event +from mlpro.bf.streams.streams.clouds import StreamMLProClouds +from mlpro.oa.streams import OAStreamScenario, OAStreamWorkflow, OAStreamTask + + + +## ------------------------------------------------------------------------------------------------ +## ------------------------------------------------------------------------------------------------ +class DDScenarioPH3D (OAStreamScenario): + + C_NAME = 'Drift Detection with PageHinkley 3D' + +## ------------------------------------------------------------------------------------------------ + def _setup(self, + p_mode, + p_ada : bool, + p_visualize : bool, + p_logging, + p_min_instances:int = 30, + p_delta: float = 0.005, + p_threshold: float = 50.0, + p_alpha: float = 0.9999, + *, + p_r_algo_mode: str = "both", + p_drift_buffer_size: int = 100, + p_instance_buffer_size: int = 20, + p_detection_steprate:int = 1, + **p_kwargs): + + # 1 Get the native stream from MLPro stream provider + stream = StreamMLProClouds( p_num_dim = 3, + p_num_instances= 50, + p_num_clouds= 2, + p_radii= [50], + p_weights=[1,2], + p_seed= 20) + + # 2 Creation of a workflow + workflow = OAStreamWorkflow( p_name='wf1', + p_range_max=OAStreamWorkflow.C_RANGE_NONE, + p_ada=p_ada, + p_visualize=p_visualize, + p_logging=p_logging ) + + # 3 Instantiation of River 'PageHinkley' drift detector + river_kswin = PageHinkley( min_instances = p_min_instances, + delta = p_delta, + threshold = p_threshold, + alpha = p_alpha, + mode = p_r_algo_mode ) + + # 4 Creation of tasks and add them to the workflow + driftdetector = WrDriftDetectorRiver2MLPro( p_algo_river = river_kswin, + p_drift_buffer_size = p_drift_buffer_size, + p_instance_buffer_size = p_instance_buffer_size, + p_detection_steprate = p_detection_steprate, + p_visualize = p_visualize, + p_logging = p_logging ) + + workflow.add_task(p_task = driftdetector ) + + # 5 Return stream and workflow + return stream, workflow + + + +## ------------------------------------------------------------------------------------------------- +## ------------------------------------------------------------------------------------------------- +# 1 Preparation of demo/unit test mode +if __name__ == "__main__": + # 1.1 Parameters for demo mode + cycle_limit = 500 + logging = Log.C_LOG_WE + step_rate = 1 + min_instances = 30 + delta = 0.05 + threshold = 50.0 + alpha = 0.9999 + r_algo_mode = "both" + drift_buffer_size = 100 + instance_buffer_size = 50 + detection_steprate = 50 + + cycle_limit = int(input(f'\nCycle limit (press ENTER for {cycle_limit}): ') or cycle_limit) + visualize = input('Visualization Y/N (press ENTER for Y): ').upper() != 'N' + if visualize: + i = input(f'Visualization step rate (press ENTER for {step_rate}): ') + if i != '': step_rate = int(i) + + i = input('Log level: "A"=All, "W"=Warnings only, "N"=Nothing (press ENTER for "W"): ').upper() + if i == 'A': logging = Log.C_LOG_WE + elif i == 'N': logging = Log.C_LOG_NOTHING + + + min_instances = int(input(f'Algo PH: Minimum number of instances (press ENTER for {min_instances}): ') or min_instances) + delta = float(input(f'Algo PH: Delta (press ENTER for {delta}): ') or delta) + threshold = float(input(f'Algo PH: Change detection threshold (press ENTER for {threshold}): ') or threshold) + alpha = float(input(f'Algo PH: Alpha (press ENTER for {alpha}): ') or alpha) + r_algo_mode = str(input(f'Algo PH: Mode (press ENTER for {r_algo_mode}): ') or r_algo_mode) + +else: + # 1.2 Parameters for internal unit test + cycle_limit = 20 + logging = Log.C_LOG_NOTHING + visualize = False + step_rate = 1 + min_instances = 30 + delta = 0.05 + threshold = 50.0 + alpha = 0.9999 + r_algo_mode = "both" + drift_buffer_size = 100 + instance_buffer_size = 10 + detection_steprate = 10 + + +# 2 Instantiate the stream scenario +myscenario = DDScenarioPH3D( p_mode = Mode.C_MODE_REAL, + p_cycle_limit = cycle_limit, + p_visualize = visualize, + p_logging = logging, + p_min_instances = min_instances, + p_delta = delta, + p_threshold = threshold, + p_alpha = alpha, + p_r_algo_mode = r_algo_mode, + p_drift_buffer_size = drift_buffer_size, + p_instance_buffer_size = instance_buffer_size, + p_detection_steprate = detection_steprate ) + +if visualize: + myscenario.init_plot( p_plot_settings=PlotSettings( p_view = PlotSettings.C_VIEW_ND, + p_view_autoselect = True, + p_step_rate = step_rate ) ) + + +# 3 Reset and run own stream scenario +myscenario.reset() + +if __name__ == '__main__': + input('Press ENTER to start stream processing...') + +myscenario.run() + + +if __name__ == '__main__': + input('Press ENTER to exit...') +