From 609b77c26951dd4825a35bed15c6889db8213421 Mon Sep 17 00:00:00 2001 From: YileAllenChen1 Date: Sun, 13 Dec 2020 01:25:58 -0600 Subject: [PATCH] add SK Interface Former-commit-id: 0cc7b46cb50414a45b06be7e6a7d5b47fdfa641e [formerly e738376659370e6115e5cabba05e820303334644] [formerly f99af0c9a81b273b15c0cf365b811c494446ddb0 [formerly df1f743cae997113882ece5b5198f778ce875309]] [formerly 0c0662663146a55d8f9cc2209ef14e2d709e8643 [formerly fc045f9a27fd8056ce3d97948eab8e331099c0bb] [formerly 5c59ed0b9ecbc89ae266b1de90779009f40b8f86 [formerly 73e36d80a04e90ca5e65059391d98c81c753e30a]]] [formerly 8aea8648b696ffa844a8caba3e58c4849b23e328 [formerly 8987be894cecfe394ded3df76a8cca1e5421cff2] [formerly 68f1e0618f29fea2aabe3a017faba2090f93021d [formerly 50e44688e2685b2ce3d04b7b8d3471f6d4559dc7]] [formerly 2634a914ff7500c6c08dc0b0d6f9e33b430449c3 [formerly 02518087237744724a40a4a94043f7f673cbcbc7] [formerly 5d34f5a15ef368001f47dcc846faafd59053a909 [formerly 1fff6fcae3bcd532a577eca5862ca3f186513e22]]]] [formerly ca44ad09f1e6dbae7b94b0ccf6bb6989a1654a96 [formerly a33af6d85135a70254947d9d9723bb99dfda1eeb] [formerly da6f823a2d6f2e46e700f55b338ca60c924f7edb [formerly f46945c0285300ad165e1503c55a472c1fffb853]] [formerly 8b322fb12410fd499440869ef2fc4cf351ccb260 [formerly 73606d900ee525d62828428191687e740e8c36a3] [formerly 02a0b89f663a93da0313b04fa3a21f12d8ef461f [formerly 77e4113ca210127ea82b95a9258db247b3cba37a]]] [formerly c3a62ba179ed2228e95f3a7893d85d21f4e295b9 [formerly 9a9aec5e7b3db2d4d31781416fe1097f3a59cfdd] [formerly 052b31817c498f9762dade3e6e5867ced661f658 [formerly 737cbbc4fd29b7e8a08b519c652ecca8e71cd8fc]] [formerly d0e9b036ccde6662b15ac67f5531f3bac9075eb3 [formerly c7220995d19ca7e4a85cc5170add8e632a078dce] [formerly c9142b33ac828923c0f74ea20d7412afb105f2cb [formerly 6284815a6d1a419f12c0ec5a66f9f8a447911458]]]]] [formerly 529ab3de293fe9e7563147e95522f005a8ba36ff [formerly 928611ef8c0305f59dfa38e04dbe8e0a232546af] [formerly 5cf5c39c6c260a76c8a11f94ec9e3d9a80866bd8 [formerly 7d25d5112dd9518bbc1de3fa9c594c4173ed0ba7]] [formerly 1ad1f6e3e54ddad3f0f8d2cf8791c33a95adf350 [formerly 4dd4c2318deaca13861130bc03371f8836ea2f4c] [formerly 4894af037d4309545363cd633b1e3c9355606820 [formerly eeb5d9abe7675332f5c9c90e0bbb8e213b2cd514]]] [formerly e5c30ea34193a9177d02a319692f6115ccba0c76 [formerly 40133eb35b7939491cdf8ff89fec3233166be0d2] [formerly 8db356c24ac207744e81c08cebc52d76dbe8efb2 [formerly 141570dd055ba33e19736123bccc33ca8f1aafd7]] [formerly 882a52077fd4668d4a53ca6124c004892cca5f88 [formerly 414beb9aca92c660ced125ce77bed5bbb4cc3190] [formerly 631ef9910905e4e2e5304d5b783fa80274facab1 [formerly 62c4871d2bd087c75becc7b180a303dd20641c20]]]] [formerly 57f258afc61367caccea3ca9719c29f4442d325d [formerly 32d6986ae5fc3bdf4b49fe5647b1b63b722e7402] [formerly 4d2d85cea8c40c5369f5d5cb4d8c002b9c1d7191 [formerly 8403bf090a54a71730071a07f0eff1034b0eb17d]] [formerly 7e514511db26a77e2aa6ce9f5c1dfcf972a4d14b [formerly 211285308e2030633bab3fb423c096c9af0369c1] [formerly dbf9db49e13f8286f438b4760fb81c479761a055 [formerly 2311de61107259722d12762d5ea7d517bd13d11a]]] [formerly 6741cfe833f23120e80768ebda9d3d62e888b219 [formerly e063bdfc6c9f83d3df6a511c485ff0f6a9aa1091] [formerly 385e389c47e3f4deb5152ea34a82db33875392c9 [formerly d5876619c54ab66f45bde85bac973b4ccf4be38b]] [formerly 5062c6d1817ab0c7ac99d1c9ec30fde12e257fb0 [formerly e8ce3c9a2ef2dc78718c3b03869a39e68a79128e] [formerly 196443b77db7545f1c84e19cc050ff72f126c883 [formerly 93c3a218bb9ddd1b2444226a0969be6483938aa6]]]]]] Former-commit-id: 15b38013d1616fad51abb70ecbdf2f3fe755a254 [formerly 3d3d71be04de49d93ca52ac00739286c011ccf28] [formerly e0ae1fa058f1f621885b8f4883b7d1814151db7b [formerly 4e81d03f614a4bdf0862da58be2b8cf930ffc76f]] [formerly e368709c7d550421a9e640715cf3083e5a1a8b67 [formerly 816e97da6f4742222c9979fe1b4835b260a8d276] [formerly 922799dff5a974aeee3e751cf5abe0ebffc59139 [formerly 58e378ff5591e231d31684ee1967bc092f773900]]] [formerly 4e03504c60d0eecb40106db70935ba841b587327 [formerly e92bf2f6c8100ed5e4ced310454991bc106bb41e] [formerly db2a97c9f53eafe79205d54ed7559daa9236228e [formerly cffbdddb7b0096594a624daf5c26ce4fa6538bfb]] [formerly ee10f6fbb3925c6fd46617be6fcc65dcd0c6342f [formerly c44576a258b88c6a59ccd79c8351b280ad79cf3b] [formerly 0030f253ec50b490e9e385bcc4a3dcbbe0083f90 [formerly 836d51e6318b7fb682defb40c3d2f7f64093e82f]]]] [formerly 1e41445ac9042baf5266c856dbac85f7bdd9e383 [formerly c24477f99065f925627987003f10891001b68714] [formerly c48471a6be4df6ada6fd0f27ac29c9758b6ac546 [formerly f235ac6c5333ae17052677e4323545a9dcd900b8]] [formerly d6195ecdd50debf38428ae30bde849fa52c6ccd2 [formerly 362d5a3c0c6236a7d565af575e7e072663a53e8e] [formerly 72fa47b5ea5b78c5a3bdd945b515f6ab06a028f4 [formerly 282b48c89b2202782e5ff29e8c5222a4e0491b81]]] [formerly 15e95cc068b44efce12d74dfe2c261d58806764a [formerly 7cc03ea195fc0d449fc9e377633870a9392a8b81] [formerly 54e79edf1d7d022b9b077b1d2372bdc11e8c0554 [formerly 96b5246eed43ee0380d87543180233df25cb5758]] [formerly 97ce4ea213d7f17212860b5a6cd809343f6ab5d3 [formerly 69f7624ba00325fa86cb42ce6c1e6736efaa9cfe] [formerly 196443b77db7545f1c84e19cc050ff72f126c883]]]] Former-commit-id: a17db9b00da4ad58caeb2838560a8eb623e2ad6b [formerly 7f87faba1923931c71f8e6349ee630d7c7cf75f0] [formerly 90533d9bcd6314e78ca0c9580c48295d80bf0020 [formerly 230416679a3723dad42f7043acc03774da69e4f2]] [formerly 03ce031ca1279aa878ecad2ecd1dc83a918c2f3e [formerly 1064d06ecef56172f93ee2691a7cdb23e13ee3f8] [formerly 29dc536dafbb6d2bd712e6fc08f62e0fc220cf2b [formerly 9377c6c73e9598167f19aa2b7c7d1aa147c00c44]]] [formerly 424955265f799c70e8b93900656ef6165e3f1b6e [formerly f5dcd4e757b180f446ec0983ef1410a674de7c6d] [formerly 21ffc1f7bfc75dee6732cd59656c1bc61fa99dcb [formerly b11273c577012f1a39957324d692e48bac7fd144]] [formerly 10d50607d8b7de833de7146dcd4621661ef4c061 [formerly cb2259eddcba7b1a73c9b6fd89ae91b893acd449] [formerly 12779223a4cd5b872362459277ab31979316e283 [formerly 4843981bf311433944fdcc1a9cfbbc07a2853d09]]]] Former-commit-id: 10a4361f94c03e729e87a098fb67b7337facf259 [formerly 257f9f9f4b0f18324ef0d83e7a2068e069cd3685] [formerly 4bd7491e618758c7e2cd28bd0f4293685be8cda2 [formerly 1e112cfac2b20f32597b26c063fa05c20d720350]] [formerly 9a66a355731c59e27042ca3ca4c7fe853aaf4d5a [formerly 6ec93e0de27946392d9804ecb7b387afc52f6d9b] [formerly 52ddf40fc54cf70ba174f32b7a1a60233487966b [formerly b2443c01c199ef7003367620f6b163fdd599895f]]] Former-commit-id: 04863097b9e8b9c6bd8a83c5a7312be0e5f8af43 [formerly e1cab2212bdc7938ebcdef96caf9c9c2e7efcee4] [formerly 05df676cd5fafb57937af99834abd21045107cd0 [formerly f7797647a15909fd0265113e403d40bec13b21ad]] Former-commit-id: 96ed7ffad3a1be00037663f9f099fc16f62192a1 [formerly 24cdf5f7212cc9216eb9aeea40e55760f0d85b7e] Former-commit-id: c4278ab2714ab1b5a0f577dc06dc990b2d3b97de --- tods/detection_algorithm/UODBasePrimitive.py | 27 ++++---- tods/tests/detection_algorithm/test_DeepLog.py | 1 - tods/tests/detection_algorithm/test_PyodABOD.py | 4 +- tods/utils/ABOD_main.py | 14 ++++ tods/utils/AutoCorrelation_main.py | 11 +++ tods/utils/AutoEncoder_main.py | 14 ++++ tods/utils/AutoRegODetectAPI.py | 23 +++++++ tods/utils/AutoRegODetector_main.py | 14 ++++ tods/utils/CBLOF_main.py | 14 ++++ tods/utils/COF_main.py | 14 ++++ tods/utils/DeepLog_main.py | 14 ++++ tods/utils/Ensemble_main.py | 14 ++++ tods/utils/HBOS_main.py | 14 ++++ tods/utils/IsolationForest_main.py | 14 ++++ tods/utils/KDiscordODetector_main.py | 14 ++++ tods/utils/KNN_main.py | 14 ++++ tods/utils/LODA_main.py | 14 ++++ tods/utils/LOF_main.py | 14 ++++ tods/utils/LSTMODetector_main.py | 14 ++++ tods/utils/MatrixProfile_main.py | 14 ++++ tods/utils/Mo_Gaal_main.py | 14 ++++ tods/utils/OCSVM_main.py | 14 ++++ tods/utils/PCAODetector_main.py | 14 ++++ tods/utils/SOD_main.py | 14 ++++ tods/utils/So_Gaal_main.py | 14 ++++ tods/utils/SystemWiseDetection_main.py | 14 ++++ tods/utils/Telemanom_main.py | 14 ++++ tods/utils/VariationalAutoEncoder_main.py | 14 ++++ tods/utils/__init__.py | 0 tods/utils/interface.py | 71 ++++++++++++++++++++ tods/utils/skinterface/__init__.py | 0 tods/utils/skinterface/entry_points.txt | 23 +++++++ tods/utils/skinterface/main_generation.py | 76 +++++++++++++++++++++ .../skinterface/primitiveSKI/ABOD_skinterface.py | 8 +++ .../primitiveSKI/AutoCorrelation_skinterface.py | 8 +++ .../primitiveSKI/AutoEncoder_skinterface.py | 8 +++ .../primitiveSKI/AutoRegODetector_skinterface.py | 8 +++ .../skinterface/primitiveSKI/Base_skinterface.py | 78 ++++++++++++++++++++++ .../skinterface/primitiveSKI/CBLOF_skinterface.py | 8 +++ .../skinterface/primitiveSKI/COF_skinterface.py | 8 +++ .../primitiveSKI/DeepLog_skinterface.py | 8 +++ .../primitiveSKI/Ensemble_skinterface.py | 8 +++ .../skinterface/primitiveSKI/HBOS_skinterface.py | 8 +++ .../primitiveSKI/IsolationForest_skinterface.py | 8 +++ .../primitiveSKI/KDiscordODetector_skinterface.py | 8 +++ .../skinterface/primitiveSKI/KNN_skinterface.py | 8 +++ .../skinterface/primitiveSKI/LODA_skinterface.py | 8 +++ .../skinterface/primitiveSKI/LOF_skinterface.py | 8 +++ .../primitiveSKI/LSTMODetector_skinterface.py | 8 +++ .../primitiveSKI/MatrixProfile_skinterface.py | 8 +++ .../primitiveSKI/Mo_Gaal_skinterface.py | 8 +++ .../skinterface/primitiveSKI/OCSVM_skinterface.py | 8 +++ .../primitiveSKI/PCAODetector_skinterface.py | 8 +++ .../skinterface/primitiveSKI/SOD_skinterface.py | 8 +++ .../primitiveSKI/So_Gaal_skinterface.py | 8 +++ .../SystemWiseDetection_skinterface.py | 8 +++ .../primitiveSKI/Telemanom_skinterface.py | 8 +++ .../VariationalAutoEncoder_skinterface.py | 8 +++ tods/utils/skinterface/primitiveSKI/__init__.py | 6 ++ tods/utils/skinterface/skinterface_generation.py | 49 ++++++++++++++ tods/utils/skinterface/test_api.sh | 27 ++++++++ tods/utils/test_main.py | 14 ++++ 62 files changed, 909 insertions(+), 15 deletions(-) create mode 100644 tods/utils/ABOD_main.py create mode 100644 tods/utils/AutoCorrelation_main.py create mode 100644 tods/utils/AutoEncoder_main.py create mode 100644 tods/utils/AutoRegODetectAPI.py create mode 100644 tods/utils/AutoRegODetector_main.py create mode 100644 tods/utils/CBLOF_main.py create mode 100644 tods/utils/COF_main.py create mode 100644 tods/utils/DeepLog_main.py create mode 100644 tods/utils/Ensemble_main.py create mode 100644 tods/utils/HBOS_main.py create mode 100644 tods/utils/IsolationForest_main.py create mode 100644 tods/utils/KDiscordODetector_main.py create mode 100644 tods/utils/KNN_main.py create mode 100644 tods/utils/LODA_main.py create mode 100644 tods/utils/LOF_main.py create mode 100644 tods/utils/LSTMODetector_main.py create mode 100644 tods/utils/MatrixProfile_main.py create mode 100644 tods/utils/Mo_Gaal_main.py create mode 100644 tods/utils/OCSVM_main.py create mode 100644 tods/utils/PCAODetector_main.py create mode 100644 tods/utils/SOD_main.py create mode 100644 tods/utils/So_Gaal_main.py create mode 100644 tods/utils/SystemWiseDetection_main.py create mode 100644 tods/utils/Telemanom_main.py create mode 100644 tods/utils/VariationalAutoEncoder_main.py create mode 100644 tods/utils/__init__.py create mode 100644 tods/utils/interface.py create mode 100644 tods/utils/skinterface/__init__.py create mode 100644 tods/utils/skinterface/entry_points.txt create mode 100644 tods/utils/skinterface/main_generation.py create mode 100644 tods/utils/skinterface/primitiveSKI/ABOD_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/Base_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/COF_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/KNN_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/LODA_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/LOF_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/SOD_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py create mode 100644 tods/utils/skinterface/primitiveSKI/__init__.py create mode 100644 tods/utils/skinterface/skinterface_generation.py create mode 100644 tods/utils/skinterface/test_api.sh create mode 100644 tods/utils/test_main.py diff --git a/tods/detection_algorithm/UODBasePrimitive.py b/tods/detection_algorithm/UODBasePrimitive.py index 2fe4000..96076f7 100755 --- a/tods/detection_algorithm/UODBasePrimitive.py +++ b/tods/detection_algorithm/UODBasePrimitive.py @@ -253,7 +253,7 @@ class UnsupervisedOutlierDetectorBase(UnsupervisedLearnerPrimitiveBase[Inputs, O if self._training_inputs is None: # pragma: no cover return CallResult(None) - + #print("self._training_indices ", self._training_indices) if len(self._training_indices) > 0: # print('Fit: ', self._clf) @@ -288,6 +288,7 @@ class UnsupervisedOutlierDetectorBase(UnsupervisedLearnerPrimitiveBase[Inputs, O if self.hyperparams['use_semantic_types']: sk_inputs = inputs.iloc[:, self._training_indices] output_columns = [] + #print("skinputs ", sk_inputs.values) if len(self._training_indices) > 0: if self.hyperparams['return_subseq_inds']: @@ -315,7 +316,7 @@ class UnsupervisedOutlierDetectorBase(UnsupervisedLearnerPrimitiveBase[Inputs, O else: sk_output, _, _ = self._clf.predict(sk_inputs.values) - # print(sk_output) + #print("sk output ", sk_output) if sparse.issparse(sk_output): # pragma: no cover sk_output = sk_output.toarray() @@ -323,16 +324,16 @@ class UnsupervisedOutlierDetectorBase(UnsupervisedLearnerPrimitiveBase[Inputs, O if len(outputs.columns) == len(self._input_column_names): outputs.columns = self._input_column_names output_columns = [outputs] - else: # pragma: no cover + else: # pragma: no cover if self.hyperparams['error_on_no_input']: raise RuntimeError("No input columns were selected") self.logger.warn("No input columns were selected") - + outputs = base_utils.combine_columns(return_result=self.hyperparams['return_result'], add_index_columns=self.hyperparams['add_index_columns'], inputs=inputs, column_indices=self._training_indices, columns_list=output_columns) - + return CallResult(outputs) def produce_score(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> CallResult[Outputs]: @@ -488,21 +489,21 @@ class UnsupervisedOutlierDetectorBase(UnsupervisedLearnerPrimitiveBase[Inputs, O Returns: list """ - + #print("*******************get columns to fit***********") if not hyperparams['use_semantic_types']: return inputs, list(range(len(inputs.columns))) inputs_metadata = inputs.metadata - - + #print("inputs_metadata ", inputs_metadata) + def can_produce_column(column_index: int) -> bool: return cls._can_produce_column(inputs_metadata, column_index, hyperparams) - + columns_to_produce, columns_not_to_produce = base_utils.get_columns_to_use(inputs_metadata, use_columns=hyperparams['use_columns'], exclude_columns=hyperparams['exclude_columns'], can_use_column=can_produce_column) - + #print("columns_to_produce ", columns_to_produce) return inputs.iloc[:, columns_to_produce], columns_to_produce # return columns_to_produce @@ -519,16 +520,18 @@ class UnsupervisedOutlierDetectorBase(UnsupervisedLearnerPrimitiveBase[Inputs, O Returns: bool """ + column_metadata = inputs_metadata.query((metadata_base.ALL_ELEMENTS, column_index)) - + #print("column metadasta ", ) accepted_structural_types = (int, float, numpy.integer, numpy.float64) accepted_semantic_types = set() accepted_semantic_types.add("https://metadata.datadrivendiscovery.org/types/Attribute") + if not issubclass(column_metadata['structural_type'], accepted_structural_types): return False semantic_types = set(column_metadata.get('semantic_types', [])) - + #print("semantic_types ", column_metadata.get('semantic_types')) if len(semantic_types) == 0: cls.logger.warning("No semantic types found in column metadata") return False diff --git a/tods/tests/detection_algorithm/test_DeepLog.py b/tods/tests/detection_algorithm/test_DeepLog.py index 07ceb77..b25664d 100644 --- a/tods/tests/detection_algorithm/test_DeepLog.py +++ b/tods/tests/detection_algorithm/test_DeepLog.py @@ -56,7 +56,6 @@ class DeepLogTest(unittest.TestCase): hyperparams_class = DeepLogPrimitive.metadata.get_hyperparams() hyperparams = hyperparams_class.defaults() hyperparams = hyperparams.replace({'batch_size': 4}) - print(hyperparams) self.primitive = DeepLogPrimitive(hyperparams=hyperparams) diff --git a/tods/tests/detection_algorithm/test_PyodABOD.py b/tods/tests/detection_algorithm/test_PyodABOD.py index 8cbf284..0efc789 100644 --- a/tods/tests/detection_algorithm/test_PyodABOD.py +++ b/tods/tests/detection_algorithm/test_PyodABOD.py @@ -56,9 +56,9 @@ class ABODTest(unittest.TestCase): hyperparams = hyperparams_class.defaults() hyperparams = hyperparams.replace({'return_result': 'new', 'method': 'default', - + }) - + print(hyperparams) primitive = ABODPrimitive(hyperparams=hyperparams) primitive.set_training_data(inputs=main) primitive.fit() diff --git a/tods/utils/ABOD_main.py b/tods/utils/ABOD_main.py new file mode 100644 index 0000000..8050958 --- /dev/null +++ b/tods/utils/ABOD_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.ABOD_skinterface import ABODSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = ABODSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/AutoCorrelation_main.py b/tods/utils/AutoCorrelation_main.py new file mode 100644 index 0000000..dedcefa --- /dev/null +++ b/tods/utils/AutoCorrelation_main.py @@ -0,0 +1,11 @@ +import numpy as np +from skinterface.primitiveSKI.AutoCorrelation_skinterface import AutoCorrelationSKI + +X = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) + +transformer = AutoCorrelationSKI(use_columns=(0,)) +results = transformer.produce(X) + +print("Primitive: ", transformer.primitive) +print("Results: \n", results) + diff --git a/tods/utils/AutoEncoder_main.py b/tods/utils/AutoEncoder_main.py new file mode 100644 index 0000000..a4faef2 --- /dev/null +++ b/tods/utils/AutoEncoder_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.AutoEncoder_skinterface import AutoEncoderSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = AutoEncoderSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/AutoRegODetectAPI.py b/tods/utils/AutoRegODetectAPI.py new file mode 100644 index 0000000..adc0e62 --- /dev/null +++ b/tods/utils/AutoRegODetectAPI.py @@ -0,0 +1,23 @@ +import numpy as np +from test_interface import SKInterface +from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive + +class AutoRegODetect(SKInterface): + def __init__(self, **hyperparams): + super().__init__(primitive=AutoRegODetectorPrimitive, **hyperparams) + + + + +if __name__ == '__main__': + X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) + X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + + transformer = AutoRegODetect(contamination=0.2, window_size=2)#use_column=(1,) + transformer.fit(X_train) + prediction_labels = transformer.produce(X_test) + prediction_score = transformer.produce_score(X_test) + + print("Prediction Labels\n", prediction_labels) + print("Prediction Score\n", prediction_score) + diff --git a/tods/utils/AutoRegODetector_main.py b/tods/utils/AutoRegODetector_main.py new file mode 100644 index 0000000..f845387 --- /dev/null +++ b/tods/utils/AutoRegODetector_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.AutoRegODetector_skinterface import AutoRegODetectorSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = AutoRegODetectorSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/CBLOF_main.py b/tods/utils/CBLOF_main.py new file mode 100644 index 0000000..bfcba07 --- /dev/null +++ b/tods/utils/CBLOF_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.CBLOF_skinterface import CBLOFSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = CBLOFSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/COF_main.py b/tods/utils/COF_main.py new file mode 100644 index 0000000..3b47094 --- /dev/null +++ b/tods/utils/COF_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.COF_skinterface import COFSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = COFSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/DeepLog_main.py b/tods/utils/DeepLog_main.py new file mode 100644 index 0000000..d95a950 --- /dev/null +++ b/tods/utils/DeepLog_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.DeepLog_skinterface import DeepLogSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = DeepLogSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/Ensemble_main.py b/tods/utils/Ensemble_main.py new file mode 100644 index 0000000..ee8f93c --- /dev/null +++ b/tods/utils/Ensemble_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.Ensemble_skinterface import EnsembleSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = EnsembleSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/HBOS_main.py b/tods/utils/HBOS_main.py new file mode 100644 index 0000000..509d866 --- /dev/null +++ b/tods/utils/HBOS_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.HBOS_skinterface import HBOSSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = HBOSSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/IsolationForest_main.py b/tods/utils/IsolationForest_main.py new file mode 100644 index 0000000..4c6844a --- /dev/null +++ b/tods/utils/IsolationForest_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.IsolationForest_skinterface import IsolationForestSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = IsolationForestSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/KDiscordODetector_main.py b/tods/utils/KDiscordODetector_main.py new file mode 100644 index 0000000..b474f7c --- /dev/null +++ b/tods/utils/KDiscordODetector_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.KDiscordODetector_skinterface import KDiscordODetectorSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = KDiscordODetectorSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/KNN_main.py b/tods/utils/KNN_main.py new file mode 100644 index 0000000..f17d31e --- /dev/null +++ b/tods/utils/KNN_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.KNN_skinterface import KNNSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = KNNSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/LODA_main.py b/tods/utils/LODA_main.py new file mode 100644 index 0000000..01f66b9 --- /dev/null +++ b/tods/utils/LODA_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.LODA_skinterface import LODASKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = LODASKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/LOF_main.py b/tods/utils/LOF_main.py new file mode 100644 index 0000000..dd77d8e --- /dev/null +++ b/tods/utils/LOF_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.LOF_skinterface import LOFSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = LOFSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/LSTMODetector_main.py b/tods/utils/LSTMODetector_main.py new file mode 100644 index 0000000..7f0d08b --- /dev/null +++ b/tods/utils/LSTMODetector_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.LSTMODetector_skinterface import LSTMODetectorSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = LSTMODetectorSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/MatrixProfile_main.py b/tods/utils/MatrixProfile_main.py new file mode 100644 index 0000000..a6cab14 --- /dev/null +++ b/tods/utils/MatrixProfile_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.MatrixProfile_skinterface import MatrixProfileSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = MatrixProfileSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/Mo_Gaal_main.py b/tods/utils/Mo_Gaal_main.py new file mode 100644 index 0000000..6b8c7b8 --- /dev/null +++ b/tods/utils/Mo_Gaal_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.Mo_Gaal_skinterface import Mo_GaalSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = Mo_GaalSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/OCSVM_main.py b/tods/utils/OCSVM_main.py new file mode 100644 index 0000000..67db169 --- /dev/null +++ b/tods/utils/OCSVM_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.OCSVM_skinterface import OCSVMSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = OCSVMSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/PCAODetector_main.py b/tods/utils/PCAODetector_main.py new file mode 100644 index 0000000..aec212e --- /dev/null +++ b/tods/utils/PCAODetector_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.PCAODetector_skinterface import PCAODetectorSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = PCAODetectorSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/SOD_main.py b/tods/utils/SOD_main.py new file mode 100644 index 0000000..3d68f87 --- /dev/null +++ b/tods/utils/SOD_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.SOD_skinterface import SODSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = SODSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/So_Gaal_main.py b/tods/utils/So_Gaal_main.py new file mode 100644 index 0000000..edc48da --- /dev/null +++ b/tods/utils/So_Gaal_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.So_Gaal_skinterface import So_GaalSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = So_GaalSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/SystemWiseDetection_main.py b/tods/utils/SystemWiseDetection_main.py new file mode 100644 index 0000000..e33518a --- /dev/null +++ b/tods/utils/SystemWiseDetection_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.SystemWiseDetection_skinterface import SystemWiseDetectionSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = SystemWiseDetectionSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/Telemanom_main.py b/tods/utils/Telemanom_main.py new file mode 100644 index 0000000..42c90d3 --- /dev/null +++ b/tods/utils/Telemanom_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.Telemanom_skinterface import TelemanomSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = TelemanomSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/VariationalAutoEncoder_main.py b/tods/utils/VariationalAutoEncoder_main.py new file mode 100644 index 0000000..6efa26d --- /dev/null +++ b/tods/utils/VariationalAutoEncoder_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.VariationalAutoEncoder_skinterface import VariationalAutoEncoderSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = VariationalAutoEncoderSKI() +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) diff --git a/tods/utils/__init__.py b/tods/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tods/utils/interface.py b/tods/utils/interface.py new file mode 100644 index 0000000..0a0ffb0 --- /dev/null +++ b/tods/utils/interface.py @@ -0,0 +1,71 @@ +from d3m import container +from tods.detection_algorithm import DeepLog +from tods.detection_algorithm.PyodABOD import ABODPrimitive +from tods.detection_algorithm.PyodAE import AutoEncoderPrimitive +from tods.detection_algorithm.PyodSOD import SODPrimitive +from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive + +class SKInterface(): + def __init__(self, primitive, hyperparameter=None): + hyperparams_class = primitive.metadata.get_hyperparams() + hyperparams = hyperparams_class.defaults() + if hyperparameter is not None: + hyperparams = hyperparams.replace(hyperparameter) + + self.primitive = primitive(hyperparams=hyperparams) + self.use_columns = hyperparams['use_columns'] + print(hyperparams) + + def transform(self, X): + if self.use_columns==(): + self.use_columns = [iter for iter in range(len(X))] + else: + pass + + inputs = {} + for i in self.use_columns: + inputs['col_'+str(i)] = list(X[i]) + inputs = container.DataFrame(inputs, columns=list(inputs.keys()), generate_metadata=True) + return inputs + + def set_training_data(self, data): + return self.primitive.set_training_data(inputs=data) + + def fit(self, data): + data = self.transform(data) + self.set_training_data(data) + return self.primitive.fit() + + def produce(self, data): + data = self.transform(data) + return self.primitive.produce(inputs=data).value + + def produce_score(self, data): + data = self.transform(data) + return self.primitive.produce_score(inputs=data).value + +if __name__ == '__main__': + import numpy as np + X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) + X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + transformer = SKInterface(AutoRegODetectorPrimitive) + transformer.fit(X_train) + prediction_labels = transformer.produce(X_test) + prediction_score = transformer.produce_score(X_test) + print("Prediction Labels\n", prediction_labels) + print("Prediction Score\n", prediction_score) + +""" + def transform(self, X): + inputs = {} + for i in range(len(X)): + inputs['col_'+str(i)] = list(X[i]) + inputs = container.DataFrame(inputs, columns=list(inputs.keys()), generate_metadata=True) + outputs = self.primitive.produce(inputs=inputs).value.to_numpy() + return outputs + + 'contamination': contamination, + 'use_columns': use_columns, + 'return_result': return_result, +""" +#use_columns=(-1,), contamination=0.1, return_result='append' \ No newline at end of file diff --git a/tods/utils/skinterface/__init__.py b/tods/utils/skinterface/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tods/utils/skinterface/entry_points.txt b/tods/utils/skinterface/entry_points.txt new file mode 100644 index 0000000..ce87b84 --- /dev/null +++ b/tods/utils/skinterface/entry_points.txt @@ -0,0 +1,23 @@ +tods.detection_algorithm.pyod_ae = tods.detection_algorithm.PyodAE:AutoEncoderPrimitive +tods.detection_algorithm.pyod_vae = tods.detection_algorithm.PyodVAE:VariationalAutoEncoderPrimitive +tods.detection_algorithm.pyod_cof = tods.detection_algorithm.PyodCOF:COFPrimitive +tods.detection_algorithm.pyod_sod = tods.detection_algorithm.PyodSOD:SODPrimitive +tods.detection_algorithm.pyod_abod = tods.detection_algorithm.PyodABOD:ABODPrimitive +tods.detection_algorithm.pyod_hbos = tods.detection_algorithm.PyodHBOS:HBOSPrimitive +tods.detection_algorithm.pyod_iforest = tods.detection_algorithm.PyodIsolationForest:IsolationForestPrimitive +tods.detection_algorithm.pyod_lof = tods.detection_algorithm.PyodLOF:LOFPrimitive +tods.detection_algorithm.pyod_knn = tods.detection_algorithm.PyodKNN:KNNPrimitive +tods.detection_algorithm.pyod_ocsvm = tods.detection_algorithm.PyodOCSVM:OCSVMPrimitive +tods.detection_algorithm.pyod_loda = tods.detection_algorithm.PyodLODA:LODAPrimitive +tods.detection_algorithm.pyod_cblof = tods.detection_algorithm.PyodCBLOF:CBLOFPrimitive +tods.detection_algorithm.pyod_sogaal = tods.detection_algorithm.PyodSoGaal:So_GaalPrimitive +tods.detection_algorithm.pyod_mogaal = tods.detection_algorithm.PyodMoGaal:Mo_GaalPrimitive +tods.detection_algorithm.matrix_profile = tods.detection_algorithm.MatrixProfile:MatrixProfilePrimitive +tods.detection_algorithm.AutoRegODetector = tods.detection_algorithm.AutoRegODetect:AutoRegODetectorPrimitive +tods.detection_algorithm.LSTMODetector = tods.detection_algorithm.LSTMODetect:LSTMODetectorPrimitive +tods.detection_algorithm.PCAODetector = tods.detection_algorithm.PCAODetect:PCAODetectorPrimitive +tods.detection_algorithm.KDiscordODetector = tods.detection_algorithm.KDiscordODetect:KDiscordODetectorPrimitive +tods.detection_algorithm.deeplog = tods.detection_algorithm.DeepLog:DeepLogPrimitive +tods.detection_algorithm.telemanom = tods.detection_algorithm.Telemanom:TelemanomPrimitive +tods.detection_algorithm.system_wise_detection = tods.detection_algorithm.SystemWiseDetection:SystemWiseDetectionPrimitive +tods.detection_algorithm.Ensemble = tods.detection_algorithm.Ensemble:EnsemblePrimitive diff --git a/tods/utils/skinterface/main_generation.py b/tods/utils/skinterface/main_generation.py new file mode 100644 index 0000000..9130916 --- /dev/null +++ b/tods/utils/skinterface/main_generation.py @@ -0,0 +1,76 @@ +#this file generates the _main.py files to test the primitives +import re +import os +import sys +#sys.path.insert(0, 'tods/utils/skinterface') +print(sys.path) +with open('tods/utils/skinterface/entry_points.txt','r',encoding='utf-8') as f: + entry_file = f.read() + +output_dir = 'tods/utils' #output directory + + +primitive_folder_start_loc_buf = [i.start()+2 for i in re.finditer('=', entry_file)] +primitive_start_loc_buf = [i.start()+1 for i in re.finditer(':', entry_file)] +primitive_end_loc_buf = [i.start() for i in re.finditer('\n', entry_file)] + +for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): + + primitive_folder_start_loc = primitive_folder_start_loc_buf[primitive_index] + primitive_end_loc = primitive_end_loc_buf[primitive_index] + + primitive_folder = entry_file[primitive_folder_start_loc:primitive_start_loc-1] + primitive_name = entry_file[primitive_start_loc:primitive_end_loc] + # print(entry_file[primitive_folder_start_loc:primitive_start_loc-1]) + # print(entry_file[primitive_start_loc:primitive_end_loc]) + + primitve_api_name = primitive_name.replace('Primitive', '_skinterface') + class_name = primitive_name.replace('Primitive', 'SKI') +# import sys +# sys.path.insert(0, 'tods/utils')""" + import_line1 = 'import numpy as np' + + import_line2 = '\nfrom skinterface.primitiveSKI.'+ primitve_api_name + ' import ' + class_name + '\n\n' + #print(import_line) + + main_line1 = """X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]])\n +""" + main_line2 = 'transformer = ' + class_name + '()' + main_line3 = """ +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\\n", prediction_labels) +print("Prediction Score\\n", prediction_score) +""" + + python_content = import_line1 + import_line2 + main_line1+main_line2+main_line3 + python_name = primitive_name.replace('Primitive', '_main.py') + + with open(os.path.join(output_dir, python_name), 'w', encoding='utf-8') as f: + f.write(python_content) + print(os.path.join(output_dir, python_name)) + print(python_content) + +""" + main_line1 = 'X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]])\n' + main_line2 = 'X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]])\n\n' + main_line3 = 'transformer = AutoRegODetectorSKI(contamination=0.2, window_size=2)\n' + main_line4 = 'transformer.fit(X_train)\n' + main_line5 = 'prediction_labels = transformer.predict(X_test)\n' + main_line6 = 'prediction_score = transformer.predict_score(X_test)\n\n' + main_line7 = 'print("Prediction Labels\n", prediction_labels)\n' + main_line8 = 'print("Prediction Score\n", prediction_score)\n' +""" +# import numpy as np +# from test_interface import SKInterface +# from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive +# +# class AutoRegODetect(SKInterface): +# def __init__(self, **hyperparams): +# super().__init__(primitive=AutoRegODetectorPrimitive, hyperparams) + + diff --git a/tods/utils/skinterface/primitiveSKI/ABOD_skinterface.py b/tods/utils/skinterface/primitiveSKI/ABOD_skinterface.py new file mode 100644 index 0000000..5d88b1e --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/ABOD_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodABOD import ABODPrimitive + +class ABODSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=ABODPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py b/tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py new file mode 100644 index 0000000..451f1c2 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.feature_analysis.AutoCorrelation import AutoCorrelationPrimitive + +class AutoCorrelationSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=AutoCorrelationPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py b/tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py new file mode 100644 index 0000000..a0bf75c --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodAE import AutoEncoderPrimitive + +class AutoEncoderSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=AutoEncoderPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py new file mode 100644 index 0000000..6783f03 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive + +class AutoRegODetectorSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=AutoRegODetectorPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/Base_skinterface.py b/tods/utils/skinterface/primitiveSKI/Base_skinterface.py new file mode 100644 index 0000000..6ece5f2 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/Base_skinterface.py @@ -0,0 +1,78 @@ +from d3m import container +from tods.detection_algorithm import DeepLog +from tods.detection_algorithm.PyodABOD import ABODPrimitive +from tods.detection_algorithm.PyodAE import AutoEncoderPrimitive +from tods.detection_algorithm.PyodSOD import SODPrimitive +from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive + +class BaseSKI(): + def __init__(self, primitive, **hyperparameter): + hyperparams_class = primitive.metadata.get_hyperparams() + hyperparams = hyperparams_class.defaults() + #print("items ", type(hyperparameter.items())) + if len(hyperparameter.items())!=0: + #for key, value in hyperparameter.items(): + hyperparams = hyperparams.replace(hyperparameter) + + self.primitive = primitive(hyperparams=hyperparams) + self.use_columns = hyperparams['use_columns'] + #print(hyperparams) + + def transform(self, X): #transform the ndarray to d3m dataframe, select columns to use + if self.use_columns==(): + self.use_columns = [iter for iter in range(len(X))] + else: + pass + + inputs = {} + for i in self.use_columns: + inputs['col_'+str(i)] = list(X[i]) + inputs = container.DataFrame(inputs, columns=list(inputs.keys()), generate_metadata=True) + return inputs + + def set_training_data(self, data): + return self.primitive.set_training_data(inputs=data) + + def fit(self, data): + data = self.transform(data) + self.set_training_data(data) + return self.primitive.fit() + + def predict(self, data): + data = self.transform(data) + return self.primitive.produce(inputs=data).value + + def predict_score(self, data): + data = self.transform(data) + return self.primitive.produce_score(inputs=data).value + + def produce(self, data): #produce function for other primitive types + data = self.transform(data) + return self.primitive.produce(inputs=data).value +""" +if __name__ == '__main__': + import numpy as np + X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) + X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + transformer = SKInterface(AutoRegODetectorPrimitive, contamination=0.2, window_size=2) + transformer.fit(X_train) + prediction_labels = transformer.produce(X_test) + prediction_score = transformer.produce_score(X_test) + print("Prediction Labels\n", prediction_labels) + print("Prediction Score\n", prediction_score) +""" + +""" + def transform(self, X): + inputs = {} + for i in range(len(X)): + inputs['col_'+str(i)] = list(X[i]) + inputs = container.DataFrame(inputs, columns=list(inputs.keys()), generate_metadata=True) + outputs = self.primitive.produce(inputs=inputs).value.to_numpy() + return outputs + + 'contamination': contamination, + 'use_columns': use_columns, + 'return_result': return_result, +""" +#use_columns=(-1,), contamination=0.1, return_result='append' \ No newline at end of file diff --git a/tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py b/tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py new file mode 100644 index 0000000..d48dccf --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodCBLOF import CBLOFPrimitive + +class CBLOFSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=CBLOFPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/COF_skinterface.py b/tods/utils/skinterface/primitiveSKI/COF_skinterface.py new file mode 100644 index 0000000..cc07b54 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/COF_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodCOF import COFPrimitive + +class COFSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=COFPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py b/tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py new file mode 100644 index 0000000..4afc9ba --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.DeepLog import DeepLogPrimitive + +class DeepLogSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=DeepLogPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py b/tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py new file mode 100644 index 0000000..4027cda --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.Ensemble import EnsemblePrimitive + +class EnsembleSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=EnsemblePrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py b/tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py new file mode 100644 index 0000000..2035cd9 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodHBOS import HBOSPrimitive + +class HBOSSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=HBOSPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py b/tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py new file mode 100644 index 0000000..32750bb --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodIsolationForest import IsolationForestPrimitive + +class IsolationForestSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=IsolationForestPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py new file mode 100644 index 0000000..9e970e1 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.KDiscordODetect import KDiscordODetectorPrimitive + +class KDiscordODetectorSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=KDiscordODetectorPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/KNN_skinterface.py b/tods/utils/skinterface/primitiveSKI/KNN_skinterface.py new file mode 100644 index 0000000..eff500c --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/KNN_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodKNN import KNNPrimitive + +class KNNSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=KNNPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/LODA_skinterface.py b/tods/utils/skinterface/primitiveSKI/LODA_skinterface.py new file mode 100644 index 0000000..390dfed --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/LODA_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodLODA import LODAPrimitive + +class LODASKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=LODAPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/LOF_skinterface.py b/tods/utils/skinterface/primitiveSKI/LOF_skinterface.py new file mode 100644 index 0000000..bde097d --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/LOF_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodLOF import LOFPrimitive + +class LOFSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=LOFPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py new file mode 100644 index 0000000..e85d850 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.LSTMODetect import LSTMODetectorPrimitive + +class LSTMODetectorSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=LSTMODetectorPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py b/tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py new file mode 100644 index 0000000..cda28af --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.MatrixProfile import MatrixProfilePrimitive + +class MatrixProfileSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=MatrixProfilePrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py b/tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py new file mode 100644 index 0000000..bfc5ada --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodMoGaal import Mo_GaalPrimitive + +class Mo_GaalSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=Mo_GaalPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py b/tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py new file mode 100644 index 0000000..2a341bb --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodOCSVM import OCSVMPrimitive + +class OCSVMSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=OCSVMPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py new file mode 100644 index 0000000..2f31d54 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PCAODetect import PCAODetectorPrimitive + +class PCAODetectorSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=PCAODetectorPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/SOD_skinterface.py b/tods/utils/skinterface/primitiveSKI/SOD_skinterface.py new file mode 100644 index 0000000..8a64d18 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/SOD_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodSOD import SODPrimitive + +class SODSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=SODPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py b/tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py new file mode 100644 index 0000000..1a4cc9d --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodSoGaal import So_GaalPrimitive + +class So_GaalSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=So_GaalPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py b/tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py new file mode 100644 index 0000000..3109276 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.SystemWiseDetection import SystemWiseDetectionPrimitive + +class SystemWiseDetectionSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=SystemWiseDetectionPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py b/tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py new file mode 100644 index 0000000..6d6b581 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.Telemanom import TelemanomPrimitive + +class TelemanomSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=TelemanomPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py b/tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py new file mode 100644 index 0000000..305a94b --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py @@ -0,0 +1,8 @@ +import numpy as np +from .Base_skinterface import BaseSKI +from tods.detection_algorithm.PyodVAE import VariationalAutoEncoderPrimitive + +class VariationalAutoEncoderSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=VariationalAutoEncoderPrimitive, **hyperparams) + diff --git a/tods/utils/skinterface/primitiveSKI/__init__.py b/tods/utils/skinterface/primitiveSKI/__init__.py new file mode 100644 index 0000000..cbc6184 --- /dev/null +++ b/tods/utils/skinterface/primitiveSKI/__init__.py @@ -0,0 +1,6 @@ +# from primitiveSKI.ABOD_skinterface import ABODSKI +# from primitiveSKI.AutoRegODetector_skinterface import AutoRegODetectorSKI +#from ABOD_skinterface import ABODSKI +#from AutoRegODetector_skinterface import AutoRegODetectorSKI +# import ABODSKI +# import AutoRegODetectorSKI \ No newline at end of file diff --git a/tods/utils/skinterface/skinterface_generation.py b/tods/utils/skinterface/skinterface_generation.py new file mode 100644 index 0000000..00d0791 --- /dev/null +++ b/tods/utils/skinterface/skinterface_generation.py @@ -0,0 +1,49 @@ + +import re +import os + +with open('tods/utils/skinterface/entry_points.txt','r',encoding='utf-8') as f: + entry_file = f.read() + +output_dir = 'tods/utils/skinterface/primitiveSKI' + + +primitive_folder_start_loc_buf = [i.start()+2 for i in re.finditer('=', entry_file)] +primitive_start_loc_buf = [i.start()+1 for i in re.finditer(':', entry_file)] +primitive_end_loc_buf = [i.start() for i in re.finditer('\n', entry_file)] + +for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): + + primitive_folder_start_loc = primitive_folder_start_loc_buf[primitive_index] + primitive_end_loc = primitive_end_loc_buf[primitive_index] + + primitive_folder = entry_file[primitive_folder_start_loc:primitive_start_loc-1] + primitive_name = entry_file[primitive_start_loc:primitive_end_loc] + # print(entry_file[primitive_folder_start_loc:primitive_start_loc-1]) + # print(entry_file[primitive_start_loc:primitive_end_loc]) + + import_line1 = 'import numpy as np \nfrom .Base_skinterface import BaseSKI\n' + import_line2 = 'from ' + primitive_folder + ' import ' + primitive_name + '\n\n' + # print(import_line) + + class_name = primitive_name.replace('Primitive', 'SKI') + class_line1 = 'class ' + class_name + '(BaseSKI):\n\tdef __init__(self, **hyperparams):\n\t\tsuper().__init__(primitive=' + class_line2 = primitive_name + ', **hyperparams)\n\n' + + python_content = import_line1 + import_line2 + class_line1 + class_line2 + python_name = primitive_name.replace('Primitive', '_skinterface.py') + with open(os.path.join(output_dir, python_name), 'w', encoding='utf-8') as f: + f.write(python_content) + #print(os.path.join(output_dir, python_name)) + print(python_content) + + +# import numpy as np +# from test_interface import SKInterface +# from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive +# +# class AutoRegODetect(SKInterface): +# def __init__(self, **hyperparams): +# super().__init__(primitive=AutoRegODetectorPrimitive, hyperparams) + + diff --git a/tods/utils/skinterface/test_api.sh b/tods/utils/skinterface/test_api.sh new file mode 100644 index 0000000..a07d8e3 --- /dev/null +++ b/tods/utils/skinterface/test_api.sh @@ -0,0 +1,27 @@ +#!/bin/bash +test_scripts=$(ls tods/utils/test_main) +for file in $test_scripts +do + for f in $tested_file + do + echo $f + echo $file + done + echo $file + + # Test pipeline building + python tods/utils/test_main/$file > tods/utils/skinterface/tmp.txt 2>>tods/utils/skinterface/tmp.txt + error=$(cat tmp.txt | grep 'Error' | wc -l) + echo "\t#Pipeline Building Errors:" $error + if [ "$error" -gt "0" ] + then + cat tods/utils/skinterface/tmp.txt + #rm tmp.txt + break + fi + echo $file >> tods/utils/skinterface/tested_file.txt +done + +# do +# for f in *.py; do python "$f"; done +# done \ No newline at end of file diff --git a/tods/utils/test_main.py b/tods/utils/test_main.py new file mode 100644 index 0000000..005e8bf --- /dev/null +++ b/tods/utils/test_main.py @@ -0,0 +1,14 @@ +import numpy as np +from skinterface.primitiveSKI.AutoRegODetector_skinterface import AutoRegODetectorSKI + +X_train = np.array([[3., 4., 8., 16, 18, 13., 22., 36., 59., 128, 62, 67, 78, 100]]) +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = AutoRegODetectorSKI(contamination=0.2, window_size=2) +transformer.fit(X_train) +prediction_labels = transformer.predict(X_test) +prediction_score = transformer.predict_score(X_test) + +print("Primitive: ", transformer.primitive) +print("Prediction Labels\n", prediction_labels) +print("Prediction Score\n", prediction_score) \ No newline at end of file