From 609b77c26951dd4825a35bed15c6889db8213421 Mon Sep 17 00:00:00 2001 From: YileAllenChen1 Date: Sun, 13 Dec 2020 01:25:58 -0600 Subject: [PATCH 1/5] 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 From 0528c7ab0ca26ecb1c3809eae1bf5a71ba1ff017 Mon Sep 17 00:00:00 2001 From: YileAllenChen1 Date: Sun, 13 Dec 2020 01:28:37 -0600 Subject: [PATCH 2/5] remove extras Former-commit-id: e5cea1a1ad57fabbb4492ea63eec57412bb5cd55 [formerly a39f5f92912962c5e38a8e91317bec3ea7fac2b6] [formerly 7b17b5a7adf0b352784653e05483d31c60580810 [formerly 2b1f2dc8d2e5edb9fad0a5ebd4cd1e507824bfdb]] [formerly cfc09981ad5554f04ed0bab3c9622e2f5df0a9bd [formerly 3c1d069cae06e38c695a0f7f2036177173204254] [formerly 62db499ecbdafd4006fc74d7e89818c676fd0aaf [formerly 44f42940d52c565401b3d5e8ce701b9dc43c0f04]]] [formerly 43ea91c5ff9b6e230404e39e2e2ea682ebb8ca86 [formerly 3b6d513435c10a1c9dfb0e141026e2ec1f84fd9e] [formerly d06da72b3c5e374de6979dc105d5843c3c423c36 [formerly ddf022e985a39dfac06b1709da32e3638793e4d3]] [formerly 8cde60716cd0d36737d38771434d4b56f9129b00 [formerly 40fb4cd373f8d262cbe132b1c8cd9ec32f6b095a] [formerly a662602d28c30c6bd900b6a6e2410b14179ace82 [formerly 982483a194f7fd60aa32ff8128bb126221705e18]]]] [formerly cd43dd84bc3743d796e5ea1844cbfafb2249342b [formerly 1fe2584c1e3ed0f9696f801d6a77c1c9b7f5f453] [formerly f61d7e5d5fe3252a0427710710845df6e6b63fc8 [formerly 718ef01860359a838c7a4ddd82718a364b0b2459]] [formerly c514cd4bd58b9c20abd6314a46f3d913bd66ca30 [formerly 3f79f1e3404cab24611b33165bee85e07b0a118b] [formerly 7d4b1e7ba8dffdd68aeaf41c9e1dc37efc4199ed [formerly 680bd0e4e133cc2ea9da49a94af785c083b07b0a]]] [formerly 837b6577d578351c6a1beb7f642d9e6039475a38 [formerly 126b14eb9f1bdac2c11625a7fa8a04ca961a9cff] [formerly f39b310f42d4e6a223f7c1e00958a6dbdb1dd2f4 [formerly f34096494cc0710534dbf6863c6d2f60779698cc]] [formerly 6881d71a7621660460be5717587119363ec6c0fe [formerly b39d72fd5418a9fe4e046edbcb9e768ed0521ff6] [formerly 4a970d70798485b009f85d2ed2fbe87096c17e68 [formerly 6683215a3fbac54d9832e4110beaea20ecf6c543]]]]] [formerly 6787d3d6f2c40deb74ed149eb6bf4997508f6add [formerly 39b7d18dfdd084c426b77095391970111e96ef63] [formerly dd7fb7980dc44e9c0d026c0a4bb4bf903aca931e [formerly a492c3818ab48bb5b23b9aba43d96b4c6d50e367]] [formerly 786ba2a7b77dc920270f89e947a32f8ace523d03 [formerly 3998e1286436ab2b2a778414fb31985ede12f122] [formerly b3fe0139c7a1960811a9ad919c5151fd25fa3f21 [formerly 44b4254b1fcb3ef8d68840eadaa0fbb4a7ae7ce4]]] [formerly fea24c48f9045282384ea20b7ee8c67b5b5ecdae [formerly 92d8cfa2712e29a9bad05cb180f229518e1d582c] [formerly 4843b581a02aef37690e8b4ef14ef4c7ccb705f7 [formerly 0de3fb98efe0aa55e17ec6999702fecf09902863]] [formerly b14a50a3bdd4f9642ded312b8f8f597ebe55afe9 [formerly 2bdd11709cfa934bc39388c0be41d810ed3d7d20] [formerly dcb8c0ef57fa2831ed91e8566a5fab8c51935a43 [formerly f7e210f15e1713edc3a3d4b9f79a27a1bfebc97f]]]] [formerly d0dd5fa78f0b330d4f66afb97e02e0a276205a92 [formerly 0ae3009a57c81b980e2ca10724998942f99357ad] [formerly 160e1f7fffd413a26276cefd094e6c3015aecdee [formerly 4931bb462a1597d1585f5a3935f22711ce1df709]] [formerly a549faaff130e0ec97b0e3cdf9babe1533944c7b [formerly ae529d3466c3b3c44656f8819e12f95a488b87d1] [formerly 478cee7974cdab3445a343b8f54353a30066a6bb [formerly ec7b54b1aae92ee4833756a7584ac4971b1dac07]]] [formerly e6306d0bdb29e0bfeb1a04aaf9d33cc0acfcd94a [formerly f74191a6eb8fc708f343c5b3c34abf292e3306be] [formerly fc2e27c0ae6a369b952170eee7db02c2779b5a4f [formerly 998036b7355e241b7d77bbcb98a2489e547320f8]] [formerly 0dd6b560fdf52e9863ce47c0b5869ae42f1b84b1 [formerly dce99a58d69571599b0cfc0f210099173abc783e] [formerly 226b580d5759443d2825f43f9a91a9fc3b48dfac [formerly 313f6be91a445ea59ab93388013743640065cbd0]]]]]] Former-commit-id: b94d741be17d3bd2fd8289ad9075bb2a1138908d [formerly 8b209eca453717646d59c8f3210188b14f3c9404] [formerly 36130ea55d9533e818aab756dd2c2c4027f538ca [formerly 130125bfd1383913df2d3112adac09e1b3e168ad]] [formerly ebb0ff8601c0f7e4f858c7218d4122c15030ad3e [formerly 778251686052c1f337b1563b7a6058c9cdcdda55] [formerly 2d08911f3881b4e346daf396f96466f6aa5a7fd5 [formerly 3ccd4ebcea74e37cadd9f6b86b30a330d5b5a0f6]]] [formerly cdf215c55527c9317771b44db8064357138a0815 [formerly 95b881d34cae196008367ccc691f63941f4d7c43] [formerly c6ae47a01f45dddbb0dd6ca92bbf7ae54fa918a0 [formerly b05f4a307ac287126f2e2f4c1d70409e25b8e4f6]] [formerly cd7dd12a467dfe26270f58d65e8f8c323b0659f5 [formerly cb09f3c61875932f7b8b6d48aa0e84903b11c12f] [formerly d60f9683c6ab5e0de9e32343f74ae330bd0d0385 [formerly 2c9930e5f70b36309f493df62ad8946d673ebb1a]]]] [formerly 9ca973d904759a2fa8eba22dfd201d1474dd16e1 [formerly fd09901c6ed000f3d1f940aee0c41f36a4034cbd] [formerly a2945d7e301d131e6a69a17266aff19f9bc22b55 [formerly e2454c6d274cad1d8fe49953d45a9bde42d16a07]] [formerly 85a30d33f198227ee2e59fda99fa41eab87003db [formerly 19a6655db7051fcd838ba830b1fefd4155fc39fe] [formerly 2505eea1732b637c58a13301e6bc8dee82a278b0 [formerly df25222f8a0c77c471a30d25bb87bef4d7bfbfb8]]] [formerly 7df818ca5af332bd5e6eeeb7b836afd311b52045 [formerly f7267cc52e6762d1794027f40fb1b72b2ed76867] [formerly 3c5a064d82cefc5e091f7aaa034a47c47bce655b [formerly edf0faed5b22d583f17e058b82a3fe5b3d94a4e2]] [formerly f15c3da551b390e566f7d1ce4ebbfb150bca64c5 [formerly d1ee728ddf003e0944f3ac52f5d5a58b27dce683] [formerly 226b580d5759443d2825f43f9a91a9fc3b48dfac]]]] Former-commit-id: 5ce28fc2774869c40b6c9ebbfb050182bffa5f76 [formerly 5777b513ea9f27d95e4e3941313c6e17dd27a68d] [formerly 05497eee56771c20cd4fd5b23f1dc823ed7dd00e [formerly 317e9d8cafce70d099bf011d318db8721100d2bb]] [formerly c682c3818759ca0a0e4537564ce4ce9a50a3a0ee [formerly cab2abfaac8d1b1a7dbfe7b01335825b8b521482] [formerly eaf9d9b00fbe20c7a6887201a7322521ae36afa2 [formerly df71dc2f460219f666eeda2d1d6e02c2b7abe219]]] [formerly 6f4832a3341ea8b1513763078d573af51258eeeb [formerly b8dc65d75f478a7bdd16af17242f5882fc2e7b00] [formerly bb61e51274d8168800ad995aa3fd12a02429608a [formerly 5665330fdd60c471a8e5480af14c17a0828308a9]] [formerly 993407f9df474d56dc43e4dde2eb3887e680f94d [formerly 3f56fd525b81682807363fc4f151d5c5ec88ec36] [formerly 20e9e442d46a8e5e9c3eb7c8e76d9abcd1b9df02 [formerly 6205e4bba5a18111d5d2d9a3393d4b7334efe005]]]] Former-commit-id: 263049457b18650e6d6bc0fd4c94e8a5060ce905 [formerly 95776666dc55e9379f62e5f5bbf177d5b62c3c11] [formerly b8dc45ce926743ab841b6ea90343430ec57f05fe [formerly 2ddcaa3a3b755beeff03a92ffdfda473714ae053]] [formerly 8594b5d67a0649e45faee9ba98d4d4ae54a28b40 [formerly 2d3e6452277863bb13f908da47d77f9859f02f8d] [formerly 157d80f68f4700f93f2ea5f8514860b93bb3bd50 [formerly 523ef8e21dd6508b40822e926efc478b72e5a323]]] Former-commit-id: 64514659b6b9eba54104fd26408092ff0e550570 [formerly d58a355a680a23d7f94a68f470dcc3125b25e00e] [formerly 030b45d96201e8bb095beeeca2de1312f2a763df [formerly 48ccfa73b044b9dc25f79117744a081fdb97d2fc]] Former-commit-id: 7a000c9ecb2e155ad3b8f32c9c788fdcf735679b [formerly feb0eda40cfde0bc5e4e86f098ae795ec575a7fb] Former-commit-id: e89a8f6adb1008d329cef9dd1b5e795db9aaa08f --- tods/utils/interface.py | 71 ------------------------------------------------- tods/utils/test_main.py | 14 ---------- 2 files changed, 85 deletions(-) delete mode 100644 tods/utils/interface.py delete mode 100644 tods/utils/test_main.py diff --git a/tods/utils/interface.py b/tods/utils/interface.py deleted file mode 100644 index 0a0ffb0..0000000 --- a/tods/utils/interface.py +++ /dev/null @@ -1,71 +0,0 @@ -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/test_main.py b/tods/utils/test_main.py deleted file mode 100644 index 005e8bf..0000000 --- a/tods/utils/test_main.py +++ /dev/null @@ -1,14 +0,0 @@ -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 From 59850e3698ee4b68919973a54c2983ab3c82e8c1 Mon Sep 17 00:00:00 2001 From: YileAllenChen1 Date: Sun, 13 Dec 2020 02:12:17 -0600 Subject: [PATCH 3/5] group into folder Former-commit-id: dc7bfbbd0c677a554df692d5ca5e15a6287102a9 [formerly 3ca744df9947d1332122d8ca18a5b1981e5eadc3] [formerly 3d16bb5bbd2b2b68a3df75950247b0ca1ea43441 [formerly 5f41e183ae6bb187f3e622d150a4f73564f11d2b]] [formerly 729a2471b43a3947fd395d5fc842187295f3caa3 [formerly b5327658f8fe13423236d7651e06744f2f34a764] [formerly 01f906b4f10d7ddbcf2fc147f10b9b291996c016 [formerly 7f0be2827fc571ae5bd662de72a1de1e001d5ebe]]] [formerly 78eb5bf681bbbd28f46acc800a707fabb29b12b4 [formerly 92482fb4aaf63a0503bc622dd10f376d994c5a93] [formerly 625c2e3a7ea8260a51f9d2002698c2f4155f83a1 [formerly 7bf6e5fa281c8532ff59f85b393a96d3b2742889]] [formerly 6d54fd6bedb67d842f196c67bb62b464db8408ef [formerly d03643875a40d0c5535db55df13a801491ae82e1] [formerly 53d12df6df27524eed90f101fee81433d1b3d5c3 [formerly 268bb82a914913ecad5a7321dd28cc44e0dd17e2]]]] [formerly 00bc78bbd3541da9778c5aaffa384d340b21e517 [formerly 0922eab7c6e50913971636986791e75c5b92ad92] [formerly 18af0b7ecd09e9688b9be76415c4adc65bf61d34 [formerly abd196b7b77b8924eef6d67c2f5f3e0b78be87d2]] [formerly 0cb85e92b341c0bf40acf974521f2f87873304ea [formerly 8e3a53b6d7442ce71ef319f2f5518a44532c9410] [formerly aef929ccdb7e8145047faf25529d94e87ac8898f [formerly 26ab8eeba0e5ad7943a9712aa8fc3628d166c80f]]] [formerly 7047bd92f1fa5f26646518831b6762c8670e0467 [formerly 8965b0faf00ed8f7ccd7b3190f57a23a3ee5500a] [formerly ab53b96565323e1f81b834725b52aa128741d63a [formerly 814f8f0f36a73d3aca9b63e89d72ed94d5501f12]] [formerly 3072224f91a97d6c8e431dfb4cadc66a8b41a24b [formerly 93fa2d4f6dbbaa205af64153dcd258bea6a55bf3] [formerly 76ab40fe1b02ff46bb950f25d7e0b6246b780c4b [formerly 3959e5ad4ad0702d2b1012fe94b2de41c2bdfaff]]]]] [formerly 4f25096e37e27a8665044d1a6dff2df677db4c37 [formerly 15a2980fb98eab84a2f78eff7a6a590750ef8534] [formerly 2338b79a16fd5caf827df70c58e76a24250332a9 [formerly 430ee94468f17cbe7f30ef9a1c1c56524e4434a0]] [formerly 9539cf1df594b2abe1debb0591558ee4c82d0185 [formerly e023b5484a4f1422a3ac8320e64ed6ac939915ed] [formerly 3f61ea1839c927333b91d20bd8acd59866ed2428 [formerly fcc6cd8f54bbb235fe8a7b229702219baa91f130]]] [formerly dfc45b03725099b33c248e9cf3b764ad54ad99bb [formerly 715350ee31522167be4af15948a070ede577bce9] [formerly 31eb8eb9363a469e3201a74cb86d28232d05acb0 [formerly 79ef03df7f97c450ff8e6ae862209beee6841f10]] [formerly 8271b2c19867b328c44af95dcc694e512bcbe801 [formerly 6f58155921d758fc29510464024005e92d1cfc0a] [formerly 1973d5c7a7eaa137bc09a11fa2916dca843f5cce [formerly a146a4f3db147fa96f488762717870d332b1306c]]]] [formerly 0ca1c64472bd5b5d8a93fb175900f1717288cc3a [formerly 0e87d6bf8a8b0eb4217333e39037cfd3956fb4fa] [formerly e4361a10c157e3d6c4f3d15bea2ad446ed097d1d [formerly eceb1696e3c3b55981033eee428f0a8a5f3834d7]] [formerly 90625762304f013e5d746656d76e384e99c458e2 [formerly 7b1577b61cce9216bd1cf904edc705abf923b90b] [formerly feae077f637278a02337873ab8fef2c177d51a8e [formerly 0f1e3701dfcd516158e156ff9840fabefbd2422a]]] [formerly e2415ee142022c5e9713c5bbc018f94d6960c206 [formerly 095d3b4211630b9dd94361dfdcff5c9f1f8327ea] [formerly 0ac0f249c101852dd01400e21ceae8c79e67821c [formerly 49acfcf617c8d573e8dd6feaa989bf402e365328]] [formerly be425739432afa148751195a18f47038cf7473ef [formerly 742f73259aab133ea5b7311d8ea67457ea777b43] [formerly e70fec1de9267b9b128c7b45f2b2530fda1326cb [formerly 3511514342be9bc9ef664299db875cc07cb70d97]]]]]] Former-commit-id: cbdc86d1963981afa92cf2fc8d2742f81e92e84d [formerly 22518f24fcd237927b094c128fed92efe6dade1e] [formerly 6a29499061027d5ee1813a8da94c4eb38f7e1f70 [formerly 3f4664f615acc4e74f77a4a5d700c32db4f297a5]] [formerly 672b52311b8d653405be3692ad31f581e833320c [formerly ffc476e91b2e20c14695d9772e7679bd7b1a5a8b] [formerly 83f13f2b62d3cf3712e4e685120e8acdc2960945 [formerly 997ad876a96b8f22d2eb4ef8802c85244ed1e02e]]] [formerly 0a74eaf4c1b2de6696400844fcba40d597bc2c0c [formerly b90f15a550571b65d6185bcc4a735fe91be248a0] [formerly 8aaab6be45c7f929b3d007e4f233f09a97d02bfd [formerly 3de83aa3f2da1efd93d17f1eaf14a35a1fba638c]] [formerly 50b16c4e09c9ffe94d9f1b6fc783acd6aaff0e52 [formerly 5dbbb455c0dc02463e56b3231f0a8d547c0c87f4] [formerly ac4f17a3f11f5c51139a03aff2aa84c0f4c79150 [formerly 3a4f876f0c8d5fedbdf626793113d7a5640ef041]]]] [formerly ad77b05e09bc429b136e0d362748dd38840a4a05 [formerly 8942efd170380534889739075907efe4b3197f61] [formerly e35fd3659c448ceec080d19ffd218a1af6d8499b [formerly 804e8443d2bf66d024c627e405959a1b1c8062fe]] [formerly e0bb5e8b11b353d0dbbb5a9d09e4c58c9863aa57 [formerly 29fb65a56ef0e69ba5299138e5814818c2c6ecd3] [formerly 4039900e8bc6d1b42b5b6ead8f5b85e4df85b8ab [formerly a18e6389387c2f5bae40ba27f27572bab3d8e4cc]]] [formerly d733af0635c0271407a4b37eb3b875ce5e7f36dc [formerly 130fa77c67f387f6809b284ebe22e28ee7190bdd] [formerly edd515d3ef599122fd8acc76f3bb3373b77372fc [formerly 8f7782ccad19397a5878e3387fa5fc42c5e78ab1]] [formerly 21ebc4753c3bc3bd141acfcd94bf329f28d300da [formerly 8e6a82ad59a3d65d84cffcfa658e2b7faa452ddf] [formerly e70fec1de9267b9b128c7b45f2b2530fda1326cb]]]] Former-commit-id: dec666697f3c3bfbbaa63cde5c65687021fb9f07 [formerly 2e605492b77cd861ac7de0f231a2a8a9f0669ddd] [formerly 6037d93bff8d7deb01da6b2c0a1123be5d7ffd44 [formerly 436cc99a3c2f9d4f640653e9ead1fd95a61f8f9e]] [formerly 178668f0d225416c48856702cbbe5e5ec5ac6692 [formerly 075d38fed49f541df0edfeded4f81f24963cfb44] [formerly 99a90daec616508adbad827fa39af3637a7d8108 [formerly 3d619f8d4238e3fc6ac6fc93883411c3659dbf8f]]] [formerly 080f9d57c9595b589aa14c55ef32ed7f20df6a6b [formerly a239a36a237a842750e75171b1e71763582fc4b9] [formerly 1aae7679679f565e92d1568127f7774ba1840bbf [formerly 6e11d426c3afa56e8fafacac8959d8496e8a4850]] [formerly 92c7495eb045251622c159afb94ac189c53b813e [formerly 9a5363b1c6333fe45803b2168d134902a16d4728] [formerly 5e94bcdbf9bae66ccd012ff0acd0d5fb6ce0c7ee [formerly 020cd2a13cf6701dc4932bbb250e41b6ef700f93]]]] Former-commit-id: 31c811bc8abc7b9d2a22bbc282f8e6b2ea7cdfef [formerly a3090b22f2310131b15cacd2c980ae91f6972ead] [formerly f8cd8cfb06ac5662cd8ea3e98ad0e63e9e9f89e5 [formerly 108f6a2ae42a8695bfd71b574167b9939d8af204]] [formerly f8c5eea6bdc98ad6a5b4e7ec01507133aff099e2 [formerly f27013177ae65774c284e95d6cc97a7c8ba95640] [formerly 1bacd4bf6310e1cdde2eaae3dc47a44ee7d6a865 [formerly c262029fae7dda6a158130d5b0e48222c009f312]]] Former-commit-id: c1a8dce78931099c6b9ef74d194535f35b516886 [formerly 4e4ece5e54078769905821ef4731aae98f17eabd] [formerly 4731a09f7a38b2b8ac58c4818f7b30646bed4c02 [formerly 223694eb2b8940968a224152d75c0aa6be124e14]] Former-commit-id: 58143b789f727f514adaad360fe79294d14312fe [formerly 0eefa0e1e2bde791a1c8c04271e206a9e7211e55] Former-commit-id: 8f4ff51cf278151de435c48c209b3dd456fbc84e --- tods/utils/ABOD_main.py | 2 +- tods/utils/AutoEncoder_main.py | 2 +- tods/utils/AutoRegODetectAPI.py | 23 ---------------------- tods/utils/AutoRegODetector_main.py | 2 +- tods/utils/CBLOF_main.py | 2 +- tods/utils/COF_main.py | 2 +- tods/utils/DeepLog_main.py | 2 +- tods/utils/Ensemble_main.py | 2 +- tods/utils/HBOS_main.py | 2 +- tods/utils/IsolationForest_main.py | 2 +- tods/utils/KDiscordODetector_main.py | 2 +- tods/utils/KNN_main.py | 2 +- tods/utils/LODA_main.py | 2 +- tods/utils/LOF_main.py | 2 +- tods/utils/LSTMODetector_main.py | 2 +- tods/utils/MatrixProfile_main.py | 2 +- tods/utils/Mo_Gaal_main.py | 2 +- tods/utils/OCSVM_main.py | 2 +- tods/utils/PCAODetector_main.py | 2 +- tods/utils/SOD_main.py | 2 +- tods/utils/So_Gaal_main.py | 2 +- tods/utils/SystemWiseDetection_main.py | 2 +- tods/utils/Telemanom_main.py | 2 +- tods/utils/VariationalAutoEncoder_main.py | 2 +- tods/utils/skinterface/main_generation.py | 2 +- .../primitiveSKI/AutoCorrelation_skinterface.py | 8 -------- tods/utils/skinterface/primitiveSKI/__init__.py | 6 ------ .../{ => detection_algorithm}/ABOD_skinterface.py | 2 +- .../AutoEncoder_skinterface.py | 2 +- .../AutoRegODetector_skinterface.py | 2 +- .../{ => detection_algorithm}/CBLOF_skinterface.py | 2 +- .../{ => detection_algorithm}/COF_skinterface.py | 2 +- .../DeepLog_skinterface.py | 2 +- .../Ensemble_skinterface.py | 2 +- .../{ => detection_algorithm}/HBOS_skinterface.py | 2 +- .../IsolationForest_skinterface.py | 2 +- .../KDiscordODetector_skinterface.py | 2 +- .../{ => detection_algorithm}/KNN_skinterface.py | 2 +- .../{ => detection_algorithm}/LODA_skinterface.py | 2 +- .../{ => detection_algorithm}/LOF_skinterface.py | 2 +- .../LSTMODetector_skinterface.py | 2 +- .../MatrixProfile_skinterface.py | 2 +- .../Mo_Gaal_skinterface.py | 2 +- .../{ => detection_algorithm}/OCSVM_skinterface.py | 2 +- .../PCAODetector_skinterface.py | 2 +- .../{ => detection_algorithm}/SOD_skinterface.py | 2 +- .../So_Gaal_skinterface.py | 2 +- .../SystemWiseDetection_skinterface.py | 2 +- .../Telemanom_skinterface.py | 2 +- .../VariationalAutoEncoder_skinterface.py | 2 +- tods/utils/skinterface/skinterface_generation.py | 6 +++--- 51 files changed, 50 insertions(+), 87 deletions(-) delete mode 100644 tods/utils/AutoRegODetectAPI.py delete mode 100644 tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py delete mode 100644 tods/utils/skinterface/primitiveSKI/__init__.py rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/ABOD_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/AutoEncoder_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/AutoRegODetector_skinterface.py (86%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/CBLOF_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/COF_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/DeepLog_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/Ensemble_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/HBOS_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/IsolationForest_skinterface.py (86%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/KDiscordODetector_skinterface.py (86%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/KNN_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/LODA_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/LOF_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/LSTMODetector_skinterface.py (85%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/MatrixProfile_skinterface.py (85%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/Mo_Gaal_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/OCSVM_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/PCAODetector_skinterface.py (85%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/SOD_skinterface.py (83%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/So_Gaal_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/SystemWiseDetection_skinterface.py (86%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/Telemanom_skinterface.py (84%) rename tods/utils/skinterface/primitiveSKI/{ => detection_algorithm}/VariationalAutoEncoder_skinterface.py (86%) diff --git a/tods/utils/ABOD_main.py b/tods/utils/ABOD_main.py index 8050958..ccba04a 100644 --- a/tods/utils/ABOD_main.py +++ b/tods/utils/ABOD_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.ABOD_skinterface import ABODSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/AutoEncoder_main.py b/tods/utils/AutoEncoder_main.py index a4faef2..92e9652 100644 --- a/tods/utils/AutoEncoder_main.py +++ b/tods/utils/AutoEncoder_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.AutoEncoder_skinterface import AutoEncoderSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/AutoRegODetectAPI.py b/tods/utils/AutoRegODetectAPI.py deleted file mode 100644 index adc0e62..0000000 --- a/tods/utils/AutoRegODetectAPI.py +++ /dev/null @@ -1,23 +0,0 @@ -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 index f845387..cab9fb5 100644 --- a/tods/utils/AutoRegODetector_main.py +++ b/tods/utils/AutoRegODetector_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.AutoRegODetector_skinterface import AutoRegODetectorSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/CBLOF_main.py b/tods/utils/CBLOF_main.py index bfcba07..f36eaf2 100644 --- a/tods/utils/CBLOF_main.py +++ b/tods/utils/CBLOF_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.CBLOF_skinterface import CBLOFSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/COF_main.py b/tods/utils/COF_main.py index 3b47094..9bd34f7 100644 --- a/tods/utils/COF_main.py +++ b/tods/utils/COF_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.COF_skinterface import COFSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/DeepLog_main.py b/tods/utils/DeepLog_main.py index d95a950..6260e40 100644 --- a/tods/utils/DeepLog_main.py +++ b/tods/utils/DeepLog_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.DeepLog_skinterface import DeepLogSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/Ensemble_main.py b/tods/utils/Ensemble_main.py index ee8f93c..7d3bf75 100644 --- a/tods/utils/Ensemble_main.py +++ b/tods/utils/Ensemble_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.Ensemble_skinterface import EnsembleSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/HBOS_main.py b/tods/utils/HBOS_main.py index 509d866..afb575c 100644 --- a/tods/utils/HBOS_main.py +++ b/tods/utils/HBOS_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.HBOS_skinterface import HBOSSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/IsolationForest_main.py b/tods/utils/IsolationForest_main.py index 4c6844a..40dc23b 100644 --- a/tods/utils/IsolationForest_main.py +++ b/tods/utils/IsolationForest_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.IsolationForest_skinterface import IsolationForestSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/KDiscordODetector_main.py b/tods/utils/KDiscordODetector_main.py index b474f7c..098d960 100644 --- a/tods/utils/KDiscordODetector_main.py +++ b/tods/utils/KDiscordODetector_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.KDiscordODetector_skinterface import KDiscordODetectorSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/KNN_main.py b/tods/utils/KNN_main.py index f17d31e..ab09833 100644 --- a/tods/utils/KNN_main.py +++ b/tods/utils/KNN_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.KNN_skinterface import KNNSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/LODA_main.py b/tods/utils/LODA_main.py index 01f66b9..31f0651 100644 --- a/tods/utils/LODA_main.py +++ b/tods/utils/LODA_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.LODA_skinterface import LODASKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/LOF_main.py b/tods/utils/LOF_main.py index dd77d8e..d6a9bcb 100644 --- a/tods/utils/LOF_main.py +++ b/tods/utils/LOF_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.LOF_skinterface import LOFSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/LSTMODetector_main.py b/tods/utils/LSTMODetector_main.py index 7f0d08b..87dd4c8 100644 --- a/tods/utils/LSTMODetector_main.py +++ b/tods/utils/LSTMODetector_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.LSTMODetector_skinterface import LSTMODetectorSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/MatrixProfile_main.py b/tods/utils/MatrixProfile_main.py index a6cab14..93816f6 100644 --- a/tods/utils/MatrixProfile_main.py +++ b/tods/utils/MatrixProfile_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.MatrixProfile_skinterface import MatrixProfileSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/Mo_Gaal_main.py b/tods/utils/Mo_Gaal_main.py index 6b8c7b8..b8238ca 100644 --- a/tods/utils/Mo_Gaal_main.py +++ b/tods/utils/Mo_Gaal_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.Mo_Gaal_skinterface import Mo_GaalSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/OCSVM_main.py b/tods/utils/OCSVM_main.py index 67db169..711efc6 100644 --- a/tods/utils/OCSVM_main.py +++ b/tods/utils/OCSVM_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.OCSVM_skinterface import OCSVMSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/PCAODetector_main.py b/tods/utils/PCAODetector_main.py index aec212e..4cb4ba2 100644 --- a/tods/utils/PCAODetector_main.py +++ b/tods/utils/PCAODetector_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.PCAODetector_skinterface import PCAODetectorSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/SOD_main.py b/tods/utils/SOD_main.py index 3d68f87..f0402af 100644 --- a/tods/utils/SOD_main.py +++ b/tods/utils/SOD_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.SOD_skinterface import SODSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/So_Gaal_main.py b/tods/utils/So_Gaal_main.py index edc48da..daa1cbf 100644 --- a/tods/utils/So_Gaal_main.py +++ b/tods/utils/So_Gaal_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.So_Gaal_skinterface import So_GaalSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/SystemWiseDetection_main.py b/tods/utils/SystemWiseDetection_main.py index e33518a..87e54b0 100644 --- a/tods/utils/SystemWiseDetection_main.py +++ b/tods/utils/SystemWiseDetection_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.SystemWiseDetection_skinterface import SystemWiseDetectionSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/Telemanom_main.py b/tods/utils/Telemanom_main.py index 42c90d3..d5e0c2f 100644 --- a/tods/utils/Telemanom_main.py +++ b/tods/utils/Telemanom_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.Telemanom_skinterface import TelemanomSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/VariationalAutoEncoder_main.py b/tods/utils/VariationalAutoEncoder_main.py index 6efa26d..8928290 100644 --- a/tods/utils/VariationalAutoEncoder_main.py +++ b/tods/utils/VariationalAutoEncoder_main.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.VariationalAutoEncoder_skinterface import VariationalAutoEncoderSKI +from skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/skinterface/main_generation.py b/tods/utils/skinterface/main_generation.py index 9130916..a146f09 100644 --- a/tods/utils/skinterface/main_generation.py +++ b/tods/utils/skinterface/main_generation.py @@ -30,7 +30,7 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): # 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' + import_line2 = '\nfrom skinterface.primitiveSKI.detection_algorithm.'+ 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]]) diff --git a/tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py b/tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py deleted file mode 100644 index 451f1c2..0000000 --- a/tods/utils/skinterface/primitiveSKI/AutoCorrelation_skinterface.py +++ /dev/null @@ -1,8 +0,0 @@ -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/__init__.py b/tods/utils/skinterface/primitiveSKI/__init__.py deleted file mode 100644 index cbc6184..0000000 --- a/tods/utils/skinterface/primitiveSKI/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -# 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/primitiveSKI/ABOD_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/ABOD_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py index 5d88b1e..5736796 100644 --- a/tods/utils/skinterface/primitiveSKI/ABOD_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodABOD import ABODPrimitive class ABODSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py index a0bf75c..3d1b470 100644 --- a/tods/utils/skinterface/primitiveSKI/AutoEncoder_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodAE import AutoEncoderPrimitive class AutoEncoderSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py similarity index 86% rename from tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py index 6783f03..0ebbdd7 100644 --- a/tods/utils/skinterface/primitiveSKI/AutoRegODetector_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive class AutoRegODetectorSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py index d48dccf..e12d1b6 100644 --- a/tods/utils/skinterface/primitiveSKI/CBLOF_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodCBLOF import CBLOFPrimitive class CBLOFSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/COF_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/COF_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py index cc07b54..785ca66 100644 --- a/tods/utils/skinterface/primitiveSKI/COF_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodCOF import COFPrimitive class COFSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py index 4afc9ba..06b793b 100644 --- a/tods/utils/skinterface/primitiveSKI/DeepLog_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.DeepLog import DeepLogPrimitive class DeepLogSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py index 4027cda..7505cff 100644 --- a/tods/utils/skinterface/primitiveSKI/Ensemble_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.Ensemble import EnsemblePrimitive class EnsembleSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py index 2035cd9..28b0cb2 100644 --- a/tods/utils/skinterface/primitiveSKI/HBOS_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodHBOS import HBOSPrimitive class HBOSSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py similarity index 86% rename from tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py index 32750bb..5e89604 100644 --- a/tods/utils/skinterface/primitiveSKI/IsolationForest_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodIsolationForest import IsolationForestPrimitive class IsolationForestSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py similarity index 86% rename from tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py index 9e970e1..8d7cd0b 100644 --- a/tods/utils/skinterface/primitiveSKI/KDiscordODetector_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.KDiscordODetect import KDiscordODetectorPrimitive class KDiscordODetectorSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/KNN_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/KNN_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py index eff500c..74c1c87 100644 --- a/tods/utils/skinterface/primitiveSKI/KNN_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodKNN import KNNPrimitive class KNNSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/LODA_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/LODA_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py index 390dfed..6565684 100644 --- a/tods/utils/skinterface/primitiveSKI/LODA_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodLODA import LODAPrimitive class LODASKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/LOF_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/LOF_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py index bde097d..b6407e9 100644 --- a/tods/utils/skinterface/primitiveSKI/LOF_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodLOF import LOFPrimitive class LOFSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py similarity index 85% rename from tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py index e85d850..fa3d4b7 100644 --- a/tods/utils/skinterface/primitiveSKI/LSTMODetector_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.LSTMODetect import LSTMODetectorPrimitive class LSTMODetectorSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py similarity index 85% rename from tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py index cda28af..306fd6d 100644 --- a/tods/utils/skinterface/primitiveSKI/MatrixProfile_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.MatrixProfile import MatrixProfilePrimitive class MatrixProfileSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py index bfc5ada..92cdeb0 100644 --- a/tods/utils/skinterface/primitiveSKI/Mo_Gaal_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodMoGaal import Mo_GaalPrimitive class Mo_GaalSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py index 2a341bb..8bec9e1 100644 --- a/tods/utils/skinterface/primitiveSKI/OCSVM_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodOCSVM import OCSVMPrimitive class OCSVMSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py similarity index 85% rename from tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py index 2f31d54..b99155f 100644 --- a/tods/utils/skinterface/primitiveSKI/PCAODetector_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PCAODetect import PCAODetectorPrimitive class PCAODetectorSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/SOD_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py similarity index 83% rename from tods/utils/skinterface/primitiveSKI/SOD_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py index 8a64d18..b16dc2c 100644 --- a/tods/utils/skinterface/primitiveSKI/SOD_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodSOD import SODPrimitive class SODSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py index 1a4cc9d..576d36a 100644 --- a/tods/utils/skinterface/primitiveSKI/So_Gaal_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodSoGaal import So_GaalPrimitive class So_GaalSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py similarity index 86% rename from tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py index 3109276..bbe042a 100644 --- a/tods/utils/skinterface/primitiveSKI/SystemWiseDetection_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.SystemWiseDetection import SystemWiseDetectionPrimitive class SystemWiseDetectionSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py similarity index 84% rename from tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py index 6d6b581..062b3f2 100644 --- a/tods/utils/skinterface/primitiveSKI/Telemanom_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.Telemanom import TelemanomPrimitive class TelemanomSKI(BaseSKI): diff --git a/tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py similarity index 86% rename from tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py rename to tods/utils/skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py index 305a94b..0be9451 100644 --- a/tods/utils/skinterface/primitiveSKI/VariationalAutoEncoder_skinterface.py +++ b/tods/utils/skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py @@ -1,5 +1,5 @@ import numpy as np -from .Base_skinterface import BaseSKI +from ..Base_skinterface import BaseSKI from tods.detection_algorithm.PyodVAE import VariationalAutoEncoderPrimitive class VariationalAutoEncoderSKI(BaseSKI): diff --git a/tods/utils/skinterface/skinterface_generation.py b/tods/utils/skinterface/skinterface_generation.py index 00d0791..9e1a3d1 100644 --- a/tods/utils/skinterface/skinterface_generation.py +++ b/tods/utils/skinterface/skinterface_generation.py @@ -5,7 +5,7 @@ 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' +output_dir = 'tods/utils/skinterface/primitiveSKI/detection_algorithm' primitive_folder_start_loc_buf = [i.start()+2 for i in re.finditer('=', entry_file)] @@ -22,7 +22,7 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): # 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_line1 = 'import numpy as np \nfrom ..Base_skinterface import BaseSKI\n' import_line2 = 'from ' + primitive_folder + ' import ' + primitive_name + '\n\n' # print(import_line) @@ -34,7 +34,7 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): 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(os.path.join(output_dir, python_name)) print(python_content) From 5fe1f1723cba1dfa4ce2aef7f4cd02d09249d6f2 Mon Sep 17 00:00:00 2001 From: YileAllenChen1 Date: Sun, 13 Dec 2020 02:15:38 -0600 Subject: [PATCH 4/5] add folders Former-commit-id: da648107dd897451a875a63b8c2eea5458f19758 [formerly b531ac710ef21767f373972b97b901f9f4389321] [formerly 82216c92321725e7452697501f1707a8c1203f21 [formerly c10b2913df2a4fe902f26ebe012a330a42c9be95]] [formerly ad0f9a215619bbaa87ba729ed6c86ff44c15edf1 [formerly ded2f5f79bdfe9482d473d90567412dd56855e85] [formerly c6e321ae9bf3fc7f982c7cd8c1ff67dbdcf6a04f [formerly 94c5dea5762020d4313e56a1a46e160429fdcb80]]] [formerly 5568b234d785bd179e56d5785fa15302a965cb6c [formerly a73c1f5e4957165ed03d6d7da249141112a2e27f] [formerly f7995d6e851b9acb2fb565d375b0085f6a143acf [formerly c51dffdc93229e255d62268388ec1190bc7e144e]] [formerly 6104b3fa70ed2adb9139f579a98889d80537336c [formerly 34ba4e5cdb0f41081f1dd0512553b14078afac43] [formerly 3c4657abbb7a12310f65fd849afdacd1faf8b2ce [formerly 1069aa5e79db0fed27ac061c5b6b4fc48ec755a8]]]] [formerly 756376b60e752369ef4b294af9124d8323bbde22 [formerly 56c5c1dc669a7e425341d781e4619c45e0dc5947] [formerly f36ae7ab93d5c32ab0b363c39e5ea8c99bc4f0ab [formerly 574dcd8cd0d58d7a9cd025027e7958869d1ee46f]] [formerly 3f530cacba1247710ff8443e523240f2ccfc5d2c [formerly eb80c5db65b6249f6c3cc520f1be115e3aa4719d] [formerly 32a39ff0f5054b89066f28d95c386d571be406b0 [formerly de4afd26e4196961eda40407a7edf3244d882122]]] [formerly 8e97f3b127efbd1b36ce2d87915854af48225d5a [formerly baeafe357c24edce2da8b9c9c51f17d07c34d5b0] [formerly 3c85b55003ef4bc9ccff1981a81a83b292be1d02 [formerly 3ba985a225560afb659b2366df7384646fefca79]] [formerly 3d4821a66b708446a737a35558b8a9af05b437da [formerly 79e36742d40a2e91e03b8d974a1237f230bbc94c] [formerly 84932e6d3a0804f1ce1e262eebdc2282e4c75e04 [formerly 0533dad3a5e65c1b4e0c198e293206c3a8c03125]]]]] [formerly 750cbc5740e588fa861e4ca1f821445651653b75 [formerly 4836254795522d416e6f4ef7cc8386e8fc234bd2] [formerly dec1b5ef6ead3da14c182d2f98a9600489e1f006 [formerly 88484e50e02f574d493038784ce15115c29c0c22]] [formerly 95638fddfb18d502a3630ebec58ac6080a3dd583 [formerly cd97dab9ae73098a9952ea95d397bb1e90180a9b] [formerly 3be1e8ae530b29d8a6a86be12e57176bb5668dc2 [formerly e429c1331dbf9359a1bc6db6e544f09450125dc2]]] [formerly 979082d6a30df43096f4f57999c30e9419a53a16 [formerly f64834b52052696904b40aa834e3abfb08d5f69b] [formerly 3d7be185b7eb7d4d32a5560d5e68ff0154ff8557 [formerly 11838f5e31285d31a47c282d86968d66f2bed208]] [formerly 8f838becc8c9ece8dfe35e1df6e2719a681bd226 [formerly 42e6a42090f640d643e9670acbd700a5fe040302] [formerly 03712a587a7259e23db58cd5cc398755e5bcd508 [formerly 16238b2c7ce4792be2957c29b0ee1030966ba6ab]]]] [formerly 6dabe5b53950f7f54a46742c80e20692b63f9c23 [formerly 7d805ed22edd93e729185372cc75a063c6a1b934] [formerly c71276c797d62f4e18857e7dbf957bf110ad4464 [formerly 8135c97fc16c18e2efd73fb8669aef95c2ad2af5]] [formerly b84321da52d091a059daa24ff1af90534a08a24a [formerly c42317f4baa7a2b24da3e202bd7107270d035231] [formerly c899bcb28132054c9566cde7f803f27814ad9cc0 [formerly b3e15039b6da13f3fdfadbb1301c4de11c190f73]]] [formerly 530acac7934d8e8e67dc8f5741237abcbde5ada8 [formerly 5b81a41e99b7142ba1425a1c5a87f7186abc2f2c] [formerly 61e45a374ded0818a6f4127b6f9c4b166b047e1e [formerly 98b9c96bfe5a6ad48abcac0d57fa7e6b516bf43b]] [formerly f436bbd6eb28fc8a79417d59b7b4659f769368ca [formerly 339d52c06404dacdb30eea048f9ffd7214a93c90] [formerly 47f0e26138af2f568f63a8a03ff4dc844f0e69a3 [formerly 98d6ca7dac74b57523ec177169ea80e67e7753ce]]]]]] Former-commit-id: caa1739886af3c09041e376737ac11bc45f5d88c [formerly 329f37fa210f80374b5b0acd32fd97ce84381c1d] [formerly 7c89e1e9fdef2deb4f8024d83d096ef6c5c0d9ea [formerly bff3b68982836d1adf33b1486b3dcaf8ffb2da7d]] [formerly 29ac436b39d91cbfe694ab9510ac083561783396 [formerly ff071a8e49c5c746f5e040374f3f9a7afa637530] [formerly 8be919a3a090f743b6040dbff2eaba5b208a88c0 [formerly 75dd2dbe05cb6c6c7f7697258565d60f98ea6458]]] [formerly 486ebaf8ae4b93f0102b41d5608f9a2bdb6e2b62 [formerly e66b1cc40e53b311f6f8949480ad120058780b59] [formerly e19bc182d425e827429b59ed6fe24ecd17e7b620 [formerly 4e809b0753bf1ad19e5b566f0fdc7d761d15811b]] [formerly 5b7873eb7b233176c0c457fcc912557a5403be18 [formerly e86714e5f07cab0a7d3ea1ffc50d5b0f9bb8ec83] [formerly b9c085a0bd2d660ef70a33fd25b13b4fbf32b6d5 [formerly 7486d3bf651ee0468c00f006c92c48f03ec6b4b1]]]] [formerly 8e1408fbbab5f8ca6d00f64abec4edf343e2b01f [formerly 5ddb5877ad62ce43879bf7f3dd1b115519c30875] [formerly ce0d3f99f3e4d6b586121c5f6d6a595a6d0e39fd [formerly 28756d9cb843fe74a9935e96a0291008e7f5c66d]] [formerly bb4efccf19886384da3b4ac9ee7a8a2be1ddc6a5 [formerly 0c2fa3d8000c9ddcb18eaeef6f12f68afa9c78af] [formerly 69e37e6ba217a0497743b72848cb132e17cf9e59 [formerly 0a39914f642d0b1fc917065aa0836d1f847ef29c]]] [formerly 54097731f63b5a5bb4511283b44071387fa618b7 [formerly 80e8e2e96edebcaabec7eca22f1ae2b620769566] [formerly 171c55863770f3c50622e38b6e0cffe74675acc1 [formerly 8ce1855fcf8c7bce73172f69da530abcab93240e]] [formerly 4a806f7a805997ff7da263b67e14a5b257b1d3e8 [formerly 705c901711ed09270cbe9a82302d1325f95bdb3a] [formerly 47f0e26138af2f568f63a8a03ff4dc844f0e69a3]]]] Former-commit-id: 0d1d0724515c5f48d9eee73b0f82fac6daea7f36 [formerly 014f85840580f6b33e21ad81223aac2b50883f09] [formerly eb24fc171fffb9d2b8eff08b6b54ab6806f165ac [formerly b0b9a297a0c5e1250ad79a0db0f7c39b06bc6a3e]] [formerly 30e6fd5fd0203af10f5fa4e85c81f8e34184d250 [formerly f9fb67f1557a21255cdb727c72d1fcf0d2e9259b] [formerly 4d375142ebcce8cf91fe888bb09a043c8e0fcf89 [formerly 27f684bac8c3d2500c671b6d57b3a17568da53ea]]] [formerly c75210fc56067dc4ec0951151bacfa3be1536d43 [formerly 07ff645baf2e5d465be495536f91dc63ae08a3b2] [formerly e1303dc67f6a4feae5f826fac3b8a206a03c3507 [formerly dc45af98036251470243fdfd59ffcf9a1b708492]] [formerly 7d3edb63ab8523627c89c2d826f11942a4d3d5e3 [formerly 16db439c534364a3f350a75d09e3efd948b56869] [formerly d505207337cb351b27e236c1cf0b4472e9a81885 [formerly d4322ad0940e347ee5c84e8517422533006813b9]]]] Former-commit-id: 9c74465cf832c30dcfdb4cf18b765656f4f76db2 [formerly eab80b986ab9a0304040726f98aa349e53840473] [formerly 1017bf7043bf7fa6be3f44acb752e01ffff351a8 [formerly e07c463878b36d686abaf2bed13abd05390f50df]] [formerly 85ded12cfae17e1d6d2faad806db01db1552d408 [formerly 0c77f5dfd49e14669afc3794e7afadda98b99340] [formerly 5e6a96b38251524da9f115bf924a4fe9066deccf [formerly b039f4e9a6aace052a98dfecad66247dcb517866]]] Former-commit-id: de6d5079609a63165e0e82f292351db9c57c4f11 [formerly 89986f8c881f5341ef6cf2ed6c0a1f1dff2d3b24] [formerly 2c0c3299adc2bb146e27e7df431df14c75c1e132 [formerly 1fa779a8058a4ab11bab0c9cc59cd7140172fa63]] Former-commit-id: fa897b535be740124ea03a390595d01587d46b0a [formerly fb6493c553a125b7391ceb71e2fc224a1650180a] Former-commit-id: 8d47bcbc3b6412b2506512ee1888f130ee8ac7f4 --- tods/utils/skinterface/primitiveSKI/data_processing/__init__.py | 0 tods/utils/skinterface/primitiveSKI/detection_algorithm/__init__.py | 0 tods/utils/skinterface/primitiveSKI/feature_analysis/__init__.py | 0 tods/utils/skinterface/primitiveSKI/timeseries_processing/__init__.py | 0 4 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 tods/utils/skinterface/primitiveSKI/data_processing/__init__.py create mode 100644 tods/utils/skinterface/primitiveSKI/detection_algorithm/__init__.py create mode 100644 tods/utils/skinterface/primitiveSKI/feature_analysis/__init__.py create mode 100644 tods/utils/skinterface/primitiveSKI/timeseries_processing/__init__.py diff --git a/tods/utils/skinterface/primitiveSKI/data_processing/__init__.py b/tods/utils/skinterface/primitiveSKI/data_processing/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/__init__.py b/tods/utils/skinterface/primitiveSKI/detection_algorithm/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tods/utils/skinterface/primitiveSKI/feature_analysis/__init__.py b/tods/utils/skinterface/primitiveSKI/feature_analysis/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tods/utils/skinterface/primitiveSKI/timeseries_processing/__init__.py b/tods/utils/skinterface/primitiveSKI/timeseries_processing/__init__.py new file mode 100644 index 0000000..e69de29 From d128ad8a20d5cf1159640b7b4557b0de552373b2 Mon Sep 17 00:00:00 2001 From: didi Date: Wed, 16 Dec 2020 12:04:31 +0800 Subject: [PATCH 5/5] Add sk interface. Former-commit-id: 05612c928d0eeb50a2195a343de6fc2e42866de7 [formerly c3c844966e69c996e3fcc1d7f5cc0483037a860d] [formerly bcf1c9293bc0ce7de4cae8f4b09698ab05c5b571 [formerly eb15a64316dc4ebfbcd49663218bcf1bb8d7c31f]] [formerly b7cb79fcd2671538fb232f2f70663804525041ba [formerly fcde90f66bdbf5d77ad36f31ccedcd500a36e7e1] [formerly 2fefe9111d651cd0833ae9ecb9df8fa3232ef950 [formerly d7a93ac24374dc0854b7405b91aafb5d90cec831]]] [formerly 18ca22bba8823b202804db6079c9ca6dfd0b6088 [formerly 5826f2d4562828c97f05d2bb5f05d969779cc62a] [formerly c83f67c9423b05dcca658ff1c2f793d3776bdd48 [formerly 0190e4b1ddde487976d518e2ef7686cdf35d69f2]] [formerly e426123f6c0d35be98f2255a9812d33199d1df06 [formerly 253995e27f1723e3262478ee14c13bc2a62ed8ce] [formerly 7013fc90231a65928be6b72260ed9b3db4d8030d [formerly ff701a74b6a9315ddba3301f7f2fa3493b75f77a]]]] [formerly 9839c55c371eee9493311dd415ee137ba9c0c47b [formerly 685ddaf9c11b9c405a1e06b7c4727b32a58bfe60] [formerly ab56e6a42fd6315d583793cfe834681434eec4b4 [formerly ef0cd95baf572dad7260703bcaefce42bcd9226f]] [formerly 46fc54a98ba861133ed20b0e3e575cdd97faf98f [formerly 8faaafa8726e99feb556babd5bb92465f60b23d7] [formerly 8036735cbf95ba9a54853649b68ac3d6ab476fe1 [formerly f85e80d388e91d07ac90d1da3ce89c1e4ff1bcda]]] [formerly 1c9f6b4d8d62cdeeb8d8f10d18970153281cf0fe [formerly d30a0f234e1b5ee53f8ab098a267c2ca25104107] [formerly 559c5c4fb4315882c2eb818cba194ba2ffec22d7 [formerly 2b726f5ec66ad9b029427dce241ac1dd8a7c3115]] [formerly 2cab19a5d839caff56a12d518826cea6015ef2c1 [formerly 93c3cd59b30165e1d520dbd203a4c34e651f7ba3] [formerly ba5aacf823a2c309d9d86422aa8e9ce13004d55e [formerly ea05c22e118c1b6af83ece2d8320712502e62d34]]]]] [formerly b39c4d0752afa75bd1e342ff3f61c4d0cf3db7cb [formerly 015d0b4101abef8527fdfe7d8dfa3aace5dce7ca] [formerly afd826c62dda87ca6d2f8bfd2f45070bfdaac4be [formerly 84a34f4890d2d2651a81733a7298749ba6283d2c]] [formerly 0c0d81736e9357f57ee58a9f40f2b9341be23bb2 [formerly 1d0aa47b285add37e6d899a8fdc25bca9f661b72] [formerly 1afb81f7d7f0ff15fa5193e9680ad5e2cc3b0149 [formerly f5cf0204d7d3d360339fb46da388481aacacfcda]]] [formerly a929a3b2c21d38d3e096f5390bbac1b2473ece64 [formerly 9a13ac2a1d7002cf6b1288125bbdcd0cda1d96d0] [formerly fa51e72f829359e16b48cff43f868f72f163fcf8 [formerly 0c025d49a517c0c6dc40502440dc73652a78a7be]] [formerly 9ac2c712d4b04171625b546500a1c19bccfedd8f [formerly a4b322043dc518ca0324b5ee5ba8fe18875e18c2] [formerly fd42ac3d64bfd57f59b8cac02e3641805b71e319 [formerly c0ad81e410e3673f818d4fbdb2527a50db7a812a]]]] [formerly cbbed232f0d8e467425387654c91ee0f0a479e06 [formerly eb5398190a6f080cbc685ca0278b5345b4da2043] [formerly b409ae5613712e0a9f0e0046a71274f43f1b689a [formerly ca99a820cbe0a9ec463fd8b6471ce7fa7880c027]] [formerly 8117ff229f0aefae9b8027e69860d5aca741ba82 [formerly 4568b38587b6fc5ac95fc9018bbf4a3d07a6a6b2] [formerly 3c660a66ed1a97a5d2d329344d34e9b558c30da3 [formerly 4994475ad340e872773c31db753129f3e080e114]]] [formerly ab0ef3f008e83895fd324acc6a71ec988174bc6b [formerly 8bca9778472deeffacd0f3bdead9f3a80b057a35] [formerly e1feef9dec849e43c375107165f8f55a09f8ab66 [formerly 18a258a73a5277bc0947d2501c33670ac625a7bc]] [formerly b7378117d6b1f46415354dfedeff4bfb2a525e82 [formerly d61555c550ad8e1bb514eb4ea404361f4f40009a] [formerly f5b4a8c6b79cea5a1e5512cadad4bbe16687df80 [formerly 9ba3c17c4fed739483897eadb775a09610badbcb]]]]]] Former-commit-id: acf098b0bb1caa63920bc7ce6d7282106554b4a7 [formerly dc2026148aefe0e871fd031f7ffaefc4b87c41c0] [formerly 8c87693eb5a151f69b871e75ed1171c91e65967e [formerly 164eebf0e100e94bba12d84bc2d7fd224fcd180c]] [formerly 5db6027d8e52d4a6e8fbcf09e1288f8ccbc28534 [formerly ab63f99a293c0f161fe0c4551bc36e76505c03a3] [formerly 4a6d1bf85e73dc339dbccc2495f35abe34c3987d [formerly 8337fe0dd8c7f37aa21a73717f7def935f0a6d1f]]] [formerly ca07e781601808b0bfcacd326f04370e4907bde6 [formerly 433a08be7c21aa8a61e58782241ae9b55de3083d] [formerly da940e4c7a7c54796a7098dc77a6d4b45998db0a [formerly da8e24f6c979d126cb8a67f218c942f273905a1e]] [formerly fa83fef323f31a9e2b94c88529b99ecc18f6a724 [formerly 1ad6b7235120fab22d957723b9750ed71608710a] [formerly 6ed90ae6dfa93c7aad8a9c5d0c6c0ec8b0cfe50a [formerly a3c96c4c861d5d0383fa0807cf4ab379e47c7e40]]]] [formerly e058b7866527efb4833e774ecc524165b2814730 [formerly 19a2a56e04b4afdd5cd96a7092fd14cefa0a19de] [formerly e23ab252217007a818b11643ccadefe97e3f8b53 [formerly f2e6577331107f3da287b4188a77488d7bea2a2b]] [formerly 12b9fe0dd15fad76e600e8b052092d8be1124130 [formerly 3804b1a886294fc3059f9a0f6975226522400d31] [formerly c8180336b212d87f83d2953bd686ee42c91f1758 [formerly a44138665a53b0b771783ba6d68365a7fbec39e9]]] [formerly 8b45d23c56b985449a2dc9a7c30ad7365bcc87de [formerly ac6fc475f3e536ca2b3d32f441c6ca14b539d976] [formerly 6ff65ba4960a80653f9e8f9862bf9e9478ab748c [formerly 10a6dc537658d666eabfec17a36e9a9ded9b4d21]] [formerly a4feb28490534a71ccb63a5c279282f30d50c76d [formerly f399e5d4a03beb46c89eab5a2f0217f9501055c0] [formerly f5b4a8c6b79cea5a1e5512cadad4bbe16687df80]]]] Former-commit-id: 2ebd5c3d7160c3ffe43fa052aa02c9238d5fe676 [formerly 002e803f06c32e656640c3365ebd46ab85e5cb69] [formerly 756d9b88939f0d4b05b21515acded363fcaef77e [formerly 161b64940aa3587740b3bb21bba058b1f910079f]] [formerly 45b40a2b8f80de56f5cf5b27d2fe65817317de11 [formerly b181df87ce4efd3c98e9e4ef46f7a4d613a13ab0] [formerly a5d7c1e9170e84c36c403f6946727ef6da2fdea0 [formerly 9d586dae1d9fa1cf5f123cedf5464bf5c5de44aa]]] [formerly 6b47ad98d06626e906e5228560050f072497b6b3 [formerly e1fb9a04d009c404015a76a3b3dc3ed295601e02] [formerly 4ebbb17588f11d50cf122cdaa416531dcfdbf7ad [formerly 3b6cb63c95468be5296d6dac036d397b203f4900]] [formerly 68bfa6f80598d85c1972af71e7f7b19d1d7b725d [formerly 8359879c23ca26bba49a38e0589f2e5c95d563c1] [formerly 0ebb979ea4d424564f02688fed723ce12f8c3c16 [formerly a5eaf95bab70648439c927647b0db0c88938d94d]]]] Former-commit-id: 9e0606866693401c686c837e6ce955c76a408717 [formerly 08f990c3d92631861d69e75a833e04e80c564545] [formerly 8f87be1ccbbb3be3c8c0b79e67bda169cad4af35 [formerly c8f505c02b2f01c707b131bb000c35ae80cf79f4]] [formerly e4d53a2790c471a8b9d7d6f889f0639309b48a39 [formerly 69919e7fd81cbc130ee2329042fb14c0cc59338a] [formerly ae874f2c9504eca5a264ca19cf9f5cda78af5ce0 [formerly 593c95b41645f0dc1dea761a5629478e7de6bcc7]]] Former-commit-id: 5c57a4200d5661edb2085c33b619d0a09af88765 [formerly e8ce21ddcf7baa2f37d8f271c683d998c9a59d47] [formerly 973d78ddc41a9d3cc5896443374c46cf2b3a87c1 [formerly 9fe316366fbf0dff1321e03d9087b1346762cbbd]] Former-commit-id: 8792d9ef9b957e3863757aefade3195c0b82cc1f [formerly b15513f9ce38e8b41f2d91e760b7898febf7fb52] Former-commit-id: 80942b6ec4707d01633f8469d366d54c30603376 --- tods/{utils => tods_skinterface}/__init__.py | 0 .../detection_algorithm_skitest/ABOD_skitest.py} | 2 +- .../AutoEncoder_skitest.py} | 2 +- .../AutoRegODetector_skitest.py} | 2 +- .../detection_algorithm_skitest/CBLOF_skitest.py} | 2 +- .../detection_algorithm_skitest/COF_skitest.py} | 2 +- .../DeepLog_skitest.py} | 2 +- .../Ensemble_skitest.py} | 2 +- .../detection_algorithm_skitest/HBOS_skitest.py} | 2 +- .../IsolationForest_skitest.py} | 2 +- .../KDiscordODetector_skitest.py} | 2 +- .../detection_algorithm_skitest/KNN_skitest.py} | 2 +- .../detection_algorithm_skitest/LODA_skitest.py} | 2 +- .../detection_algorithm_skitest/LOF_skitest.py} | 2 +- .../LSTMODetector_skitest.py} | 2 +- .../MatrixProfile_skitest.py} | 2 +- .../Mo_Gaal_skitest.py} | 2 +- .../detection_algorithm_skitest/OCSVM_skitest.py} | 2 +- .../PCAODetector_skitest.py} | 2 +- .../detection_algorithm_skitest/SOD_skitest.py} | 2 +- .../So_Gaal_skitest.py} | 2 +- .../SystemWiseDetection_skitest.py} | 2 +- .../Telemanom_skitest.py} | 2 +- .../VariationalAutoEncoder_skitest.py} | 2 +- .../tods_skinterface/entry_points/entry_points.txt | 82 ++++++++++++++++++++++ .../entry_points_detection_algorithm.txt} | 0 .../entry_points/entry_points_feature_analysis.txt | 33 +++++++++ .../AutoCorrelation_skitest.py | 10 +++ .../feature_analysis_skitest/BKFilter_skitest.py | 10 +++ .../DiscreteCosineTransform_skitest.py | 10 +++ .../FastFourierTransform_skitest.py | 10 +++ .../feature_analysis_skitest/HPFilter_skitest.py | 10 +++ .../NonNegativeMatrixFactorization_skitest.py | 10 +++ .../SKTruncatedSVD_skitest.py | 10 +++ .../SpectralResidualTransform_skitest.py | 10 +++ .../StatisticalAbsEnergy_skitest.py | 10 +++ .../StatisticalAbsSum_skitest.py | 10 +++ .../StatisticalGmean_skitest.py | 10 +++ .../StatisticalHmean_skitest.py | 10 +++ .../StatisticalKurtosis_skitest.py | 10 +++ .../StatisticalMaximum_skitest.py | 10 +++ ...StatisticalMeanAbsTemporalDerivative_skitest.py | 10 +++ .../StatisticalMeanAbs_skitest.py | 10 +++ .../StatisticalMeanTemporalDerivative_skitest.py | 10 +++ .../StatisticalMean_skitest.py | 10 +++ .../StatisticalMedianAbsoluteDeviation_skitest.py | 10 +++ .../StatisticalMedian_skitest.py | 10 +++ .../StatisticalMinimum_skitest.py | 10 +++ .../StatisticalSkew_skitest.py | 10 +++ .../StatisticalStd_skitest.py | 10 +++ .../StatisticalVar_skitest.py | 10 +++ .../StatisticalVariation_skitest.py | 10 +++ .../StatisticalVecSum_skitest.py | 10 +++ .../StatisticalWillisonAmplitude_skitest.py | 10 +++ .../StatisticalZeroCrossing_skitest.py | 10 +++ .../feature_analysis_skitest/TRMF_skitest.py | 10 +++ .../WaveletTransform_skitest.py | 10 +++ .../primitiveSKI/Base_skinterface.py | 45 +++++++++--- .../primitiveSKI}/__init__.py | 0 .../primitiveSKI/data_processing/__init__.py | 0 .../detection_algorithm/ABOD_skinterface.py | 4 +- .../detection_algorithm/AutoEncoder_skinterface.py | 4 +- .../AutoRegODetector_skinterface.py | 4 +- .../detection_algorithm/CBLOF_skinterface.py | 4 +- .../detection_algorithm/COF_skinterface.py | 4 +- .../detection_algorithm/DeepLog_skinterface.py | 4 +- .../detection_algorithm/Ensemble_skinterface.py | 4 +- .../detection_algorithm/HBOS_skinterface.py | 4 +- .../IsolationForest_skinterface.py | 4 +- .../KDiscordODetector_skinterface.py | 4 +- .../detection_algorithm/KNN_skinterface.py | 4 +- .../detection_algorithm/LODA_skinterface.py | 4 +- .../detection_algorithm/LOF_skinterface.py | 4 +- .../LSTMODetector_skinterface.py | 4 +- .../MatrixProfile_skinterface.py | 4 +- .../detection_algorithm/Mo_Gaal_skinterface.py | 4 +- .../detection_algorithm/OCSVM_skinterface.py | 4 +- .../PCAODetector_skinterface.py | 4 +- .../detection_algorithm/SOD_skinterface.py | 4 +- .../detection_algorithm/So_Gaal_skinterface.py | 4 +- .../SystemWiseDetection_skinterface.py | 4 +- .../detection_algorithm/Telemanom_skinterface.py | 4 +- .../VariationalAutoEncoder_skinterface.py | 4 +- .../primitiveSKI/detection_algorithm/__init__.py | 0 .../AutoCorrelation_skinterface.py | 10 +++ .../feature_analysis/BKFilter_skinterface.py | 10 +++ .../DiscreteCosineTransform_skinterface.py | 10 +++ .../FastFourierTransform_skinterface.py | 10 +++ .../feature_analysis/HPFilter_skinterface.py | 10 +++ .../NonNegativeMatrixFactorization_skinterface.py | 10 +++ .../feature_analysis/SKTruncatedSVD_skinterface.py | 10 +++ .../SpectralResidualTransform_skinterface.py | 10 +++ .../StatisticalAbsEnergy_skinterface.py | 10 +++ .../StatisticalAbsSum_skinterface.py | 10 +++ .../StatisticalGmean_skinterface.py | 10 +++ .../StatisticalHmean_skinterface.py | 10 +++ .../StatisticalKurtosis_skinterface.py | 10 +++ .../StatisticalMaximum_skinterface.py | 10 +++ ...isticalMeanAbsTemporalDerivative_skinterface.py | 10 +++ .../StatisticalMeanAbs_skinterface.py | 10 +++ ...tatisticalMeanTemporalDerivative_skinterface.py | 10 +++ .../StatisticalMean_skinterface.py | 10 +++ ...atisticalMedianAbsoluteDeviation_skinterface.py | 10 +++ .../StatisticalMedian_skinterface.py | 10 +++ .../StatisticalMinimum_skinterface.py | 10 +++ .../StatisticalSkew_skinterface.py | 10 +++ .../feature_analysis/StatisticalStd_skinterface.py | 10 +++ .../feature_analysis/StatisticalVar_skinterface.py | 10 +++ .../StatisticalVariation_skinterface.py | 10 +++ .../StatisticalVecSum_skinterface.py | 10 +++ .../StatisticalWillisonAmplitude_skinterface.py | 10 +++ .../StatisticalZeroCrossing_skinterface.py | 10 +++ .../feature_analysis/TRMF_skinterface.py | 10 +++ .../WaveletTransform_skinterface.py | 10 +++ .../primitiveSKI/feature_analysis/__init__.py | 0 .../primitiveSKI/timeseries_processing/__init__.py | 0 .../detection_algorithm_skinterface_generation.py} | 9 +-- .../detection_algorithm_skitest_generation.py} | 8 +-- .../feature_analysis_skinterface_generation.py | 41 +++++++++++ .../feature_analysis_skitest_generation.py | 72 +++++++++++++++++++ .../skinterface => tods_skinterface}/test_api.sh | 0 tods/utils/AutoCorrelation_main.py | 11 --- 122 files changed, 965 insertions(+), 74 deletions(-) rename tods/{utils => tods_skinterface}/__init__.py (100%) rename tods/{utils/ABOD_main.py => tods_skinterface/detection_algorithm_skitest/ABOD_skitest.py} (83%) rename tods/{utils/AutoEncoder_main.py => tods_skinterface/detection_algorithm_skitest/AutoEncoder_skitest.py} (81%) rename tods/{utils/AutoRegODetector_main.py => tods_skinterface/detection_algorithm_skitest/AutoRegODetector_skitest.py} (80%) rename tods/{utils/CBLOF_main.py => tods_skinterface/detection_algorithm_skitest/CBLOF_skitest.py} (83%) rename tods/{utils/COF_main.py => tods_skinterface/detection_algorithm_skitest/COF_skitest.py} (84%) rename tods/{utils/DeepLog_main.py => tods_skinterface/detection_algorithm_skitest/DeepLog_skitest.py} (82%) rename tods/{utils/Ensemble_main.py => tods_skinterface/detection_algorithm_skitest/Ensemble_skitest.py} (82%) rename tods/{utils/HBOS_main.py => tods_skinterface/detection_algorithm_skitest/HBOS_skitest.py} (83%) rename tods/{utils/IsolationForest_main.py => tods_skinterface/detection_algorithm_skitest/IsolationForest_skitest.py} (80%) rename tods/{utils/KDiscordODetector_main.py => tods_skinterface/detection_algorithm_skitest/KDiscordODetector_skitest.py} (80%) rename tods/{utils/KNN_main.py => tods_skinterface/detection_algorithm_skitest/KNN_skitest.py} (84%) rename tods/{utils/LODA_main.py => tods_skinterface/detection_algorithm_skitest/LODA_skitest.py} (83%) rename tods/{utils/LOF_main.py => tods_skinterface/detection_algorithm_skitest/LOF_skitest.py} (84%) rename tods/{utils/LSTMODetector_main.py => tods_skinterface/detection_algorithm_skitest/LSTMODetector_skitest.py} (81%) rename tods/{utils/MatrixProfile_main.py => tods_skinterface/detection_algorithm_skitest/MatrixProfile_skitest.py} (81%) rename tods/{utils/Mo_Gaal_main.py => tods_skinterface/detection_algorithm_skitest/Mo_Gaal_skitest.py} (82%) rename tods/{utils/OCSVM_main.py => tods_skinterface/detection_algorithm_skitest/OCSVM_skitest.py} (83%) rename tods/{utils/PCAODetector_main.py => tods_skinterface/detection_algorithm_skitest/PCAODetector_skitest.py} (81%) rename tods/{utils/SOD_main.py => tods_skinterface/detection_algorithm_skitest/SOD_skitest.py} (84%) rename tods/{utils/So_Gaal_main.py => tods_skinterface/detection_algorithm_skitest/So_Gaal_skitest.py} (82%) rename tods/{utils/SystemWiseDetection_main.py => tods_skinterface/detection_algorithm_skitest/SystemWiseDetection_skitest.py} (80%) rename tods/{utils/Telemanom_main.py => tods_skinterface/detection_algorithm_skitest/Telemanom_skitest.py} (82%) rename tods/{utils/VariationalAutoEncoder_main.py => tods_skinterface/detection_algorithm_skitest/VariationalAutoEncoder_skitest.py} (79%) create mode 100644 tods/tods_skinterface/entry_points/entry_points.txt rename tods/{utils/skinterface/entry_points.txt => tods_skinterface/entry_points/entry_points_detection_algorithm.txt} (100%) create mode 100644 tods/tods_skinterface/entry_points/entry_points_feature_analysis.txt create mode 100644 tods/tods_skinterface/feature_analysis_skitest/AutoCorrelation_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/BKFilter_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/DiscreteCosineTransform_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/FastFourierTransform_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/HPFilter_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/NonNegativeMatrixFactorization_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/SKTruncatedSVD_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/SpectralResidualTransform_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsEnergy_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsSum_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalGmean_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalHmean_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalKurtosis_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMaximum_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbsTemporalDerivative_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbs_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanTemporalDerivative_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMean_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMedianAbsoluteDeviation_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMedian_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalMinimum_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalSkew_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalStd_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalVar_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalVariation_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalVecSum_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalWillisonAmplitude_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/StatisticalZeroCrossing_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/TRMF_skitest.py create mode 100644 tods/tods_skinterface/feature_analysis_skitest/WaveletTransform_skitest.py rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/Base_skinterface.py (61%) rename tods/{utils/skinterface => tods_skinterface/primitiveSKI}/__init__.py (100%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/data_processing/__init__.py (100%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/ABOD_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py (73%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py (75%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/CBLOF_skinterface.py (72%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/COF_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/DeepLog_skinterface.py (72%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/Ensemble_skinterface.py (72%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/HBOS_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py (75%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py (75%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/KNN_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/LODA_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/LOF_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py (74%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py (74%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py (72%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/OCSVM_skinterface.py (72%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py (74%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/SOD_skinterface.py (71%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py (72%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py (76%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/Telemanom_skinterface.py (73%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py (75%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/detection_algorithm/__init__.py (100%) create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/AutoCorrelation_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/BKFilter_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/DiscreteCosineTransform_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/FastFourierTransform_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/HPFilter_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/NonNegativeMatrixFactorization_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/SKTruncatedSVD_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/SpectralResidualTransform_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsEnergy_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsSum_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalGmean_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalHmean_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalKurtosis_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMaximum_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbsTemporalDerivative_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbs_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanTemporalDerivative_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMean_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedianAbsoluteDeviation_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedian_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMinimum_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalSkew_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalStd_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVar_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVariation_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVecSum_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalWillisonAmplitude_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalZeroCrossing_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/TRMF_skinterface.py create mode 100644 tods/tods_skinterface/primitiveSKI/feature_analysis/WaveletTransform_skinterface.py rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/feature_analysis/__init__.py (100%) rename tods/{utils/skinterface => tods_skinterface}/primitiveSKI/timeseries_processing/__init__.py (100%) rename tods/{utils/skinterface/skinterface_generation.py => tods_skinterface/script_generation/detection_algorithm_skinterface_generation.py} (83%) rename tods/{utils/skinterface/main_generation.py => tods_skinterface/script_generation/detection_algorithm_skitest_generation.py} (88%) create mode 100644 tods/tods_skinterface/script_generation/feature_analysis_skinterface_generation.py create mode 100644 tods/tods_skinterface/script_generation/feature_analysis_skitest_generation.py rename tods/{utils/skinterface => tods_skinterface}/test_api.sh (100%) delete mode 100644 tods/utils/AutoCorrelation_main.py diff --git a/tods/utils/__init__.py b/tods/tods_skinterface/__init__.py similarity index 100% rename from tods/utils/__init__.py rename to tods/tods_skinterface/__init__.py diff --git a/tods/utils/ABOD_main.py b/tods/tods_skinterface/detection_algorithm_skitest/ABOD_skitest.py similarity index 83% rename from tods/utils/ABOD_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/ABOD_skitest.py index ccba04a..fe33576 100644 --- a/tods/utils/ABOD_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/ABOD_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.ABOD_skinterface import ABODSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/AutoEncoder_main.py b/tods/tods_skinterface/detection_algorithm_skitest/AutoEncoder_skitest.py similarity index 81% rename from tods/utils/AutoEncoder_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/AutoEncoder_skitest.py index 92e9652..eb55a2b 100644 --- a/tods/utils/AutoEncoder_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/AutoEncoder_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.AutoEncoder_skinterface import AutoEncoderSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/AutoRegODetector_main.py b/tods/tods_skinterface/detection_algorithm_skitest/AutoRegODetector_skitest.py similarity index 80% rename from tods/utils/AutoRegODetector_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/AutoRegODetector_skitest.py index cab9fb5..ac7a84a 100644 --- a/tods/utils/AutoRegODetector_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/AutoRegODetector_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.AutoRegODetector_skinterface import AutoRegODetectorSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/CBLOF_main.py b/tods/tods_skinterface/detection_algorithm_skitest/CBLOF_skitest.py similarity index 83% rename from tods/utils/CBLOF_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/CBLOF_skitest.py index f36eaf2..0ecdb30 100644 --- a/tods/utils/CBLOF_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/CBLOF_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.CBLOF_skinterface import CBLOFSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/COF_main.py b/tods/tods_skinterface/detection_algorithm_skitest/COF_skitest.py similarity index 84% rename from tods/utils/COF_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/COF_skitest.py index 9bd34f7..3294775 100644 --- a/tods/utils/COF_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/COF_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.COF_skinterface import COFSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/DeepLog_main.py b/tods/tods_skinterface/detection_algorithm_skitest/DeepLog_skitest.py similarity index 82% rename from tods/utils/DeepLog_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/DeepLog_skitest.py index 6260e40..81dad2c 100644 --- a/tods/utils/DeepLog_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/DeepLog_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.DeepLog_skinterface import DeepLogSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/Ensemble_main.py b/tods/tods_skinterface/detection_algorithm_skitest/Ensemble_skitest.py similarity index 82% rename from tods/utils/Ensemble_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/Ensemble_skitest.py index 7d3bf75..9b5e5e1 100644 --- a/tods/utils/Ensemble_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/Ensemble_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.Ensemble_skinterface import EnsembleSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/HBOS_main.py b/tods/tods_skinterface/detection_algorithm_skitest/HBOS_skitest.py similarity index 83% rename from tods/utils/HBOS_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/HBOS_skitest.py index afb575c..54d2def 100644 --- a/tods/utils/HBOS_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/HBOS_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.HBOS_skinterface import HBOSSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/IsolationForest_main.py b/tods/tods_skinterface/detection_algorithm_skitest/IsolationForest_skitest.py similarity index 80% rename from tods/utils/IsolationForest_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/IsolationForest_skitest.py index 40dc23b..40d022e 100644 --- a/tods/utils/IsolationForest_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/IsolationForest_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.IsolationForest_skinterface import IsolationForestSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/KDiscordODetector_main.py b/tods/tods_skinterface/detection_algorithm_skitest/KDiscordODetector_skitest.py similarity index 80% rename from tods/utils/KDiscordODetector_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/KDiscordODetector_skitest.py index 098d960..209a0dd 100644 --- a/tods/utils/KDiscordODetector_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/KDiscordODetector_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.KDiscordODetector_skinterface import KDiscordODetectorSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/KNN_main.py b/tods/tods_skinterface/detection_algorithm_skitest/KNN_skitest.py similarity index 84% rename from tods/utils/KNN_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/KNN_skitest.py index ab09833..0824508 100644 --- a/tods/utils/KNN_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/KNN_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.KNN_skinterface import KNNSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/LODA_main.py b/tods/tods_skinterface/detection_algorithm_skitest/LODA_skitest.py similarity index 83% rename from tods/utils/LODA_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/LODA_skitest.py index 31f0651..dd4c577 100644 --- a/tods/utils/LODA_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/LODA_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.LODA_skinterface import LODASKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/LOF_main.py b/tods/tods_skinterface/detection_algorithm_skitest/LOF_skitest.py similarity index 84% rename from tods/utils/LOF_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/LOF_skitest.py index d6a9bcb..9e8f55f 100644 --- a/tods/utils/LOF_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/LOF_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.LOF_skinterface import LOFSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/LSTMODetector_main.py b/tods/tods_skinterface/detection_algorithm_skitest/LSTMODetector_skitest.py similarity index 81% rename from tods/utils/LSTMODetector_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/LSTMODetector_skitest.py index 87dd4c8..8a61e2b 100644 --- a/tods/utils/LSTMODetector_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/LSTMODetector_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.LSTMODetector_skinterface import LSTMODetectorSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/MatrixProfile_main.py b/tods/tods_skinterface/detection_algorithm_skitest/MatrixProfile_skitest.py similarity index 81% rename from tods/utils/MatrixProfile_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/MatrixProfile_skitest.py index 93816f6..54ef73d 100644 --- a/tods/utils/MatrixProfile_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/MatrixProfile_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.MatrixProfile_skinterface import MatrixProfileSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/Mo_Gaal_main.py b/tods/tods_skinterface/detection_algorithm_skitest/Mo_Gaal_skitest.py similarity index 82% rename from tods/utils/Mo_Gaal_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/Mo_Gaal_skitest.py index b8238ca..cefa4ee 100644 --- a/tods/utils/Mo_Gaal_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/Mo_Gaal_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.Mo_Gaal_skinterface import Mo_GaalSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/OCSVM_main.py b/tods/tods_skinterface/detection_algorithm_skitest/OCSVM_skitest.py similarity index 83% rename from tods/utils/OCSVM_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/OCSVM_skitest.py index 711efc6..2e4ee8e 100644 --- a/tods/utils/OCSVM_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/OCSVM_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.OCSVM_skinterface import OCSVMSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/PCAODetector_main.py b/tods/tods_skinterface/detection_algorithm_skitest/PCAODetector_skitest.py similarity index 81% rename from tods/utils/PCAODetector_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/PCAODetector_skitest.py index 4cb4ba2..63547f9 100644 --- a/tods/utils/PCAODetector_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/PCAODetector_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.PCAODetector_skinterface import PCAODetectorSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/SOD_main.py b/tods/tods_skinterface/detection_algorithm_skitest/SOD_skitest.py similarity index 84% rename from tods/utils/SOD_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/SOD_skitest.py index f0402af..f33e08c 100644 --- a/tods/utils/SOD_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/SOD_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.SOD_skinterface import SODSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/So_Gaal_main.py b/tods/tods_skinterface/detection_algorithm_skitest/So_Gaal_skitest.py similarity index 82% rename from tods/utils/So_Gaal_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/So_Gaal_skitest.py index daa1cbf..5756868 100644 --- a/tods/utils/So_Gaal_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/So_Gaal_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.So_Gaal_skinterface import So_GaalSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/SystemWiseDetection_main.py b/tods/tods_skinterface/detection_algorithm_skitest/SystemWiseDetection_skitest.py similarity index 80% rename from tods/utils/SystemWiseDetection_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/SystemWiseDetection_skitest.py index 87e54b0..ac135c3 100644 --- a/tods/utils/SystemWiseDetection_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/SystemWiseDetection_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.SystemWiseDetection_skinterface import SystemWiseDetectionSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/Telemanom_main.py b/tods/tods_skinterface/detection_algorithm_skitest/Telemanom_skitest.py similarity index 82% rename from tods/utils/Telemanom_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/Telemanom_skitest.py index d5e0c2f..3dc5de7 100644 --- a/tods/utils/Telemanom_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/Telemanom_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.Telemanom_skinterface import TelemanomSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/utils/VariationalAutoEncoder_main.py b/tods/tods_skinterface/detection_algorithm_skitest/VariationalAutoEncoder_skitest.py similarity index 79% rename from tods/utils/VariationalAutoEncoder_main.py rename to tods/tods_skinterface/detection_algorithm_skitest/VariationalAutoEncoder_skitest.py index 8928290..2a78aa9 100644 --- a/tods/utils/VariationalAutoEncoder_main.py +++ b/tods/tods_skinterface/detection_algorithm_skitest/VariationalAutoEncoder_skitest.py @@ -1,5 +1,5 @@ import numpy as np -from skinterface.primitiveSKI.detection_algorithm.VariationalAutoEncoder_skinterface import VariationalAutoEncoderSKI +from tods.tods_skinterface.primitiveSKI.detection_algorithm.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]]) diff --git a/tods/tods_skinterface/entry_points/entry_points.txt b/tods/tods_skinterface/entry_points/entry_points.txt new file mode 100644 index 0000000..7e3075e --- /dev/null +++ b/tods/tods_skinterface/entry_points/entry_points.txt @@ -0,0 +1,82 @@ +[d3m.primitives] +tods.data_processing.dataset_to_dataframe = tods.data_processing.DatasetToDataframe:DatasetToDataFramePrimitive +tods.data_processing.time_interval_transform = tods.data_processing.TimeIntervalTransform:TimeIntervalTransformPrimitive +tods.data_processing.categorical_to_binary = tods.data_processing.CategoricalToBinary:CategoricalToBinaryPrimitive +tods.data_processing.column_filter = tods.data_processing.ColumnFilter:ColumnFilterPrimitive +tods.data_processing.timestamp_validation = tods.data_processing.TimeStampValidation:TimeStampValidationPrimitive +tods.data_processing.duplication_validation = tods.data_processing.DuplicationValidation:DuplicationValidationPrimitive +tods.data_processing.continuity_validation = tods.data_processing.ContinuityValidation:ContinuityValidationPrimitive +tods.data_processing.impute_missing = tods.data_processing.SKImputer:SKImputerPrimitive + + +tods.timeseries_processing.transformation.axiswise_scaler = tods.timeseries_processing.SKAxiswiseScaler:SKAxiswiseScalerPrimitive +tods.timeseries_processing.transformation.standard_scaler = tods.timeseries_processing.SKStandardScaler:SKStandardScalerPrimitive +tods.timeseries_processing.transformation.power_transformer = tods.timeseries_processing.SKPowerTransformer:SKPowerTransformerPrimitive +tods.timeseries_processing.transformation.quantile_transformer = tods.timeseries_processing.SKQuantileTransformer:SKQuantileTransformerPrimitive +tods.timeseries_processing.transformation.moving_average_transform = tods.timeseries_processing.MovingAverageTransformer:MovingAverageTransformerPrimitive +tods.timeseries_processing.transformation.simple_exponential_smoothing = tods.timeseries_processing.SimpleExponentialSmoothing:SimpleExponentialSmoothingPrimitive +tods.timeseries_processing.transformation.holt_smoothing = tods.timeseries_processing.HoltSmoothing:HoltSmoothingPrimitive +tods.timeseries_processing.transformation.holt_winters_exponential_smoothing= tods.timeseries_processing.HoltWintersExponentialSmoothing:HoltWintersExponentialSmoothingPrimitive +tods.timeseries_processing.decomposition.time_series_seasonality_trend_decomposition = tods.timeseries_processing.TimeSeriesSeasonalityTrendDecomposition:TimeSeriesSeasonalityTrendDecompositionPrimitive + + +tods.feature_analysis.auto_correlation = tods.feature_analysis.AutoCorrelation:AutoCorrelationPrimitive +tods.feature_analysis.statistical_mean = tods.feature_analysis.StatisticalMean:StatisticalMeanPrimitive +tods.feature_analysis.statistical_median = tods.feature_analysis.StatisticalMedian:StatisticalMedianPrimitive +tods.feature_analysis.statistical_g_mean = tods.feature_analysis.StatisticalGmean:StatisticalGmeanPrimitive +tods.feature_analysis.statistical_abs_energy = tods.feature_analysis.StatisticalAbsEnergy:StatisticalAbsEnergyPrimitive +tods.feature_analysis.statistical_abs_sum = tods.feature_analysis.StatisticalAbsSum:StatisticalAbsSumPrimitive +tods.feature_analysis.statistical_h_mean = tods.feature_analysis.StatisticalHmean:StatisticalHmeanPrimitive +tods.feature_analysis.statistical_maximum = tods.feature_analysis.StatisticalMaximum:StatisticalMaximumPrimitive +tods.feature_analysis.statistical_minimum = tods.feature_analysis.StatisticalMinimum:StatisticalMinimumPrimitive +tods.feature_analysis.statistical_mean_abs = tods.feature_analysis.StatisticalMeanAbs:StatisticalMeanAbsPrimitive +tods.feature_analysis.statistical_mean_abs_temporal_derivative = tods.feature_analysis.StatisticalMeanAbsTemporalDerivative:StatisticalMeanAbsTemporalDerivativePrimitive +tods.feature_analysis.statistical_mean_temporal_derivative = tods.feature_analysis.StatisticalMeanTemporalDerivative:StatisticalMeanTemporalDerivativePrimitive +tods.feature_analysis.statistical_median_abs_deviation = tods.feature_analysis.StatisticalMedianAbsoluteDeviation:StatisticalMedianAbsoluteDeviationPrimitive +tods.feature_analysis.statistical_kurtosis = tods.feature_analysis.StatisticalKurtosis:StatisticalKurtosisPrimitive +tods.feature_analysis.statistical_skew = tods.feature_analysis.StatisticalSkew:StatisticalSkewPrimitive +tods.feature_analysis.statistical_std = tods.feature_analysis.StatisticalStd:StatisticalStdPrimitive +tods.feature_analysis.statistical_var = tods.feature_analysis.StatisticalVar:StatisticalVarPrimitive +tods.feature_analysis.statistical_variation = tods.feature_analysis.StatisticalVariation:StatisticalVariationPrimitive +tods.feature_analysis.statistical_vec_sum = tods.feature_analysis.StatisticalVecSum:StatisticalVecSumPrimitive +tods.feature_analysis.statistical_willison_amplitude = tods.feature_analysis.StatisticalWillisonAmplitude:StatisticalWillisonAmplitudePrimitive +tods.feature_analysis.statistical_zero_crossing = tods.feature_analysis.StatisticalZeroCrossing:StatisticalZeroCrossingPrimitive +tods.feature_analysis.spectral_residual_transform = tods.feature_analysis.SpectralResidualTransform:SpectralResidualTransformPrimitive +tods.feature_analysis.fast_fourier_transform = tods.feature_analysis.FastFourierTransform:FastFourierTransformPrimitive +tods.feature_analysis.discrete_cosine_transform = tods.feature_analysis.DiscreteCosineTransform:DiscreteCosineTransformPrimitive +tods.feature_analysis.non_negative_matrix_factorization = tods.feature_analysis.NonNegativeMatrixFactorization:NonNegativeMatrixFactorizationPrimitive +tods.feature_analysis.bk_filter = tods.feature_analysis.BKFilter:BKFilterPrimitive +tods.feature_analysis.hp_filter = tods.feature_analysis.HPFilter:HPFilterPrimitive +tods.feature_analysis.truncated_svd = tods.feature_analysis.SKTruncatedSVD:SKTruncatedSVDPrimitive +tods.feature_analysis.wavelet_transform = tods.feature_analysis.WaveletTransform:WaveletTransformPrimitive +tods.feature_analysis.trmf = tods.feature_analysis.TRMF:TRMFPrimitive + + +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 + +tods.reinforcement.rule_filter = tods.reinforcement.RuleBasedFilter:RuleBasedFilter + diff --git a/tods/utils/skinterface/entry_points.txt b/tods/tods_skinterface/entry_points/entry_points_detection_algorithm.txt similarity index 100% rename from tods/utils/skinterface/entry_points.txt rename to tods/tods_skinterface/entry_points/entry_points_detection_algorithm.txt diff --git a/tods/tods_skinterface/entry_points/entry_points_feature_analysis.txt b/tods/tods_skinterface/entry_points/entry_points_feature_analysis.txt new file mode 100644 index 0000000..cb28fcb --- /dev/null +++ b/tods/tods_skinterface/entry_points/entry_points_feature_analysis.txt @@ -0,0 +1,33 @@ +tods.feature_analysis.auto_correlation = tods.feature_analysis.AutoCorrelation:AutoCorrelationPrimitive +tods.feature_analysis.statistical_mean = tods.feature_analysis.StatisticalMean:StatisticalMeanPrimitive +tods.feature_analysis.statistical_median = tods.feature_analysis.StatisticalMedian:StatisticalMedianPrimitive +tods.feature_analysis.statistical_g_mean = tods.feature_analysis.StatisticalGmean:StatisticalGmeanPrimitive +tods.feature_analysis.statistical_abs_energy = tods.feature_analysis.StatisticalAbsEnergy:StatisticalAbsEnergyPrimitive +tods.feature_analysis.statistical_abs_sum = tods.feature_analysis.StatisticalAbsSum:StatisticalAbsSumPrimitive +tods.feature_analysis.statistical_h_mean = tods.feature_analysis.StatisticalHmean:StatisticalHmeanPrimitive +tods.feature_analysis.statistical_maximum = tods.feature_analysis.StatisticalMaximum:StatisticalMaximumPrimitive +tods.feature_analysis.statistical_minimum = tods.feature_analysis.StatisticalMinimum:StatisticalMinimumPrimitive +tods.feature_analysis.statistical_mean_abs = tods.feature_analysis.StatisticalMeanAbs:StatisticalMeanAbsPrimitive +tods.feature_analysis.statistical_mean_abs_temporal_derivative = tods.feature_analysis.StatisticalMeanAbsTemporalDerivative:StatisticalMeanAbsTemporalDerivativePrimitive +tods.feature_analysis.statistical_mean_temporal_derivative = tods.feature_analysis.StatisticalMeanTemporalDerivative:StatisticalMeanTemporalDerivativePrimitive +tods.feature_analysis.statistical_median_abs_deviation = tods.feature_analysis.StatisticalMedianAbsoluteDeviation:StatisticalMedianAbsoluteDeviationPrimitive +tods.feature_analysis.statistical_kurtosis = tods.feature_analysis.StatisticalKurtosis:StatisticalKurtosisPrimitive +tods.feature_analysis.statistical_skew = tods.feature_analysis.StatisticalSkew:StatisticalSkewPrimitive +tods.feature_analysis.statistical_std = tods.feature_analysis.StatisticalStd:StatisticalStdPrimitive +tods.feature_analysis.statistical_var = tods.feature_analysis.StatisticalVar:StatisticalVarPrimitive +tods.feature_analysis.statistical_variation = tods.feature_analysis.StatisticalVariation:StatisticalVariationPrimitive +tods.feature_analysis.statistical_vec_sum = tods.feature_analysis.StatisticalVecSum:StatisticalVecSumPrimitive +tods.feature_analysis.statistical_willison_amplitude = tods.feature_analysis.StatisticalWillisonAmplitude:StatisticalWillisonAmplitudePrimitive +tods.feature_analysis.statistical_zero_crossing = tods.feature_analysis.StatisticalZeroCrossing:StatisticalZeroCrossingPrimitive +tods.feature_analysis.spectral_residual_transform = tods.feature_analysis.SpectralResidualTransform:SpectralResidualTransformPrimitive +tods.feature_analysis.fast_fourier_transform = tods.feature_analysis.FastFourierTransform:FastFourierTransformPrimitive +tods.feature_analysis.discrete_cosine_transform = tods.feature_analysis.DiscreteCosineTransform:DiscreteCosineTransformPrimitive +tods.feature_analysis.non_negative_matrix_factorization = tods.feature_analysis.NonNegativeMatrixFactorization:NonNegativeMatrixFactorizationPrimitive +tods.feature_analysis.bk_filter = tods.feature_analysis.BKFilter:BKFilterPrimitive +tods.feature_analysis.hp_filter = tods.feature_analysis.HPFilter:HPFilterPrimitive +tods.feature_analysis.truncated_svd = tods.feature_analysis.SKTruncatedSVD:SKTruncatedSVDPrimitive +tods.feature_analysis.wavelet_transform = tods.feature_analysis.WaveletTransform:WaveletTransformPrimitive +tods.feature_analysis.trmf = tods.feature_analysis.TRMF:TRMFPrimitive + + + diff --git a/tods/tods_skinterface/feature_analysis_skitest/AutoCorrelation_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/AutoCorrelation_skitest.py new file mode 100644 index 0000000..b21e8d4 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/AutoCorrelation_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.AutoCorrelation_skinterface import AutoCorrelationSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = AutoCorrelationSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/BKFilter_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/BKFilter_skitest.py new file mode 100644 index 0000000..8d21ff8 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/BKFilter_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.BKFilter_skinterface import BKFilterSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = BKFilterSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/DiscreteCosineTransform_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/DiscreteCosineTransform_skitest.py new file mode 100644 index 0000000..1b390d5 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/DiscreteCosineTransform_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.DiscreteCosineTransform_skinterface import DiscreteCosineTransformSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = DiscreteCosineTransformSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/FastFourierTransform_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/FastFourierTransform_skitest.py new file mode 100644 index 0000000..ac2de98 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/FastFourierTransform_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.FastFourierTransform_skinterface import FastFourierTransformSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = FastFourierTransformSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/HPFilter_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/HPFilter_skitest.py new file mode 100644 index 0000000..5c02b3d --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/HPFilter_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.HPFilter_skinterface import HPFilterSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = HPFilterSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/NonNegativeMatrixFactorization_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/NonNegativeMatrixFactorization_skitest.py new file mode 100644 index 0000000..ecabc49 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/NonNegativeMatrixFactorization_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.NonNegativeMatrixFactorization_skinterface import NonNegativeMatrixFactorizationSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = NonNegativeMatrixFactorizationSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/SKTruncatedSVD_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/SKTruncatedSVD_skitest.py new file mode 100644 index 0000000..01b49bb --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/SKTruncatedSVD_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.SKTruncatedSVD_skinterface import SKTruncatedSVDSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = SKTruncatedSVDSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/SpectralResidualTransform_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/SpectralResidualTransform_skitest.py new file mode 100644 index 0000000..8f63291 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/SpectralResidualTransform_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.SpectralResidualTransform_skinterface import SpectralResidualTransformSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = SpectralResidualTransformSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsEnergy_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsEnergy_skitest.py new file mode 100644 index 0000000..953b14c --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsEnergy_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalAbsEnergy_skinterface import StatisticalAbsEnergySKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalAbsEnergySKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsSum_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsSum_skitest.py new file mode 100644 index 0000000..9d3fbff --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalAbsSum_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalAbsSum_skinterface import StatisticalAbsSumSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalAbsSumSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalGmean_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalGmean_skitest.py new file mode 100644 index 0000000..1e9a9fd --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalGmean_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalGmean_skinterface import StatisticalGmeanSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalGmeanSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalHmean_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalHmean_skitest.py new file mode 100644 index 0000000..cd0ddea --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalHmean_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalHmean_skinterface import StatisticalHmeanSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalHmeanSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalKurtosis_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalKurtosis_skitest.py new file mode 100644 index 0000000..172bd45 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalKurtosis_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalKurtosis_skinterface import StatisticalKurtosisSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalKurtosisSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMaximum_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMaximum_skitest.py new file mode 100644 index 0000000..29b31e6 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMaximum_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMaximum_skinterface import StatisticalMaximumSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMaximumSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbsTemporalDerivative_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbsTemporalDerivative_skitest.py new file mode 100644 index 0000000..9b9af2a --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbsTemporalDerivative_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMeanAbsTemporalDerivative_skinterface import StatisticalMeanAbsTemporalDerivativeSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMeanAbsTemporalDerivativeSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbs_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbs_skitest.py new file mode 100644 index 0000000..af3a701 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanAbs_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMeanAbs_skinterface import StatisticalMeanAbsSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMeanAbsSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanTemporalDerivative_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanTemporalDerivative_skitest.py new file mode 100644 index 0000000..0c57237 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMeanTemporalDerivative_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMeanTemporalDerivative_skinterface import StatisticalMeanTemporalDerivativeSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMeanTemporalDerivativeSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMean_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMean_skitest.py new file mode 100644 index 0000000..aa3827d --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMean_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMean_skinterface import StatisticalMeanSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMeanSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMedianAbsoluteDeviation_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMedianAbsoluteDeviation_skitest.py new file mode 100644 index 0000000..2f0d34a --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMedianAbsoluteDeviation_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMedianAbsoluteDeviation_skinterface import StatisticalMedianAbsoluteDeviationSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMedianAbsoluteDeviationSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMedian_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMedian_skitest.py new file mode 100644 index 0000000..1235fc9 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMedian_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMedian_skinterface import StatisticalMedianSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMedianSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalMinimum_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMinimum_skitest.py new file mode 100644 index 0000000..1afdb7e --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalMinimum_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalMinimum_skinterface import StatisticalMinimumSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalMinimumSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalSkew_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalSkew_skitest.py new file mode 100644 index 0000000..90e0356 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalSkew_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalSkew_skinterface import StatisticalSkewSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalSkewSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalStd_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalStd_skitest.py new file mode 100644 index 0000000..33f42c9 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalStd_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalStd_skinterface import StatisticalStdSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalStdSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalVar_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalVar_skitest.py new file mode 100644 index 0000000..c4048ce --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalVar_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalVar_skinterface import StatisticalVarSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalVarSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalVariation_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalVariation_skitest.py new file mode 100644 index 0000000..fb288f7 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalVariation_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalVariation_skinterface import StatisticalVariationSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalVariationSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalVecSum_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalVecSum_skitest.py new file mode 100644 index 0000000..17e12a6 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalVecSum_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalVecSum_skinterface import StatisticalVecSumSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalVecSumSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalWillisonAmplitude_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalWillisonAmplitude_skitest.py new file mode 100644 index 0000000..9e89fa5 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalWillisonAmplitude_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalWillisonAmplitude_skinterface import StatisticalWillisonAmplitudeSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalWillisonAmplitudeSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/StatisticalZeroCrossing_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/StatisticalZeroCrossing_skitest.py new file mode 100644 index 0000000..0c3e042 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/StatisticalZeroCrossing_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.StatisticalZeroCrossing_skinterface import StatisticalZeroCrossingSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = StatisticalZeroCrossingSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/TRMF_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/TRMF_skitest.py new file mode 100644 index 0000000..6e189e4 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/TRMF_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.TRMF_skinterface import TRMFSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = TRMFSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/tods_skinterface/feature_analysis_skitest/WaveletTransform_skitest.py b/tods/tods_skinterface/feature_analysis_skitest/WaveletTransform_skitest.py new file mode 100644 index 0000000..ba387d2 --- /dev/null +++ b/tods/tods_skinterface/feature_analysis_skitest/WaveletTransform_skitest.py @@ -0,0 +1,10 @@ +import numpy as np +from tods.tods_skinterface.primitiveSKI.feature_analysis.WaveletTransform_skinterface import WaveletTransformSKI + +X_test = np.array([[3., 4., 8.6, 13.4, 22.5, 17, 19.2, 36.1, 127, -23, 59.2]]) + +transformer = WaveletTransformSKI() +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\n", X_transform) diff --git a/tods/utils/skinterface/primitiveSKI/Base_skinterface.py b/tods/tods_skinterface/primitiveSKI/Base_skinterface.py similarity index 61% rename from tods/utils/skinterface/primitiveSKI/Base_skinterface.py rename to tods/tods_skinterface/primitiveSKI/Base_skinterface.py index 6ece5f2..76ef244 100644 --- a/tods/utils/skinterface/primitiveSKI/Base_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/Base_skinterface.py @@ -7,6 +7,13 @@ from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive class BaseSKI(): def __init__(self, primitive, **hyperparameter): + + hyperparam_buf = list(primitive.metadata.get_hyperparams().defaults().keys()) + hyperparam_input = list(hyperparameter.keys()) + if not set(hyperparam_buf) > set(hyperparam_input): + invalid_hyperparam = list(set(hyperparam_input) - set(hyperparam_buf)) + raise TypeError(self.__class__.__name__ + ' got unexpected keyword argument ' + str(invalid_hyperparam)) + hyperparams_class = primitive.metadata.get_hyperparams() hyperparams = hyperparams_class.defaults() #print("items ", type(hyperparameter.items())) @@ -15,17 +22,21 @@ class BaseSKI(): hyperparams = hyperparams.replace(hyperparameter) self.primitive = primitive(hyperparams=hyperparams) - self.use_columns = hyperparams['use_columns'] + self.fit_available = False + self.predict_available = False + self.produce_available = False #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 + # if self.use_columns==(): + # self.use_columns = [iter for iter in range(len(X))] + # else: + # pass + # print(self.use_columns) + use_columns = [iter for iter in range(len(X))] inputs = {} - for i in self.use_columns: + for i in use_columns: inputs['col_'+str(i)] = list(X[i]) inputs = container.DataFrame(inputs, columns=list(inputs.keys()), generate_metadata=True) return inputs @@ -34,21 +45,37 @@ class BaseSKI(): return self.primitive.set_training_data(inputs=data) def fit(self, data): + + if not self.fit_available: + raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'fit\'') + data = self.transform(data) self.set_training_data(data) return self.primitive.fit() def predict(self, data): + + if not self.predict_available: + raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'predict\'') + data = self.transform(data) - return self.primitive.produce(inputs=data).value + return self.primitive.produce(inputs=data).value.values def predict_score(self, data): + + if not self.predict_available: + raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'predict_score\'') + data = self.transform(data) - return self.primitive.produce_score(inputs=data).value + return self.primitive.produce_score(inputs=data).value.values def produce(self, data): #produce function for other primitive types + + if not self.produce_available: + raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'produce\'') + data = self.transform(data) - return self.primitive.produce(inputs=data).value + return self.primitive.produce(inputs=data).value.values """ if __name__ == '__main__': import numpy as np diff --git a/tods/utils/skinterface/__init__.py b/tods/tods_skinterface/primitiveSKI/__init__.py similarity index 100% rename from tods/utils/skinterface/__init__.py rename to tods/tods_skinterface/primitiveSKI/__init__.py diff --git a/tods/utils/skinterface/primitiveSKI/data_processing/__init__.py b/tods/tods_skinterface/primitiveSKI/data_processing/__init__.py similarity index 100% rename from tods/utils/skinterface/primitiveSKI/data_processing/__init__.py rename to tods/tods_skinterface/primitiveSKI/data_processing/__init__.py diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py index 5736796..31df643 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodABOD import ABODPrimitive class ABODSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=ABODPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py similarity index 73% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py index 3d1b470..3c62a46 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodAE import AutoEncoderPrimitive class AutoEncoderSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=AutoEncoderPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py similarity index 75% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py index 0ebbdd7..57c137a 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive class AutoRegODetectorSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=AutoRegODetectorPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py similarity index 72% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py index e12d1b6..d7b044d 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodCBLOF import CBLOFPrimitive class CBLOFSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=CBLOFPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py index 785ca66..ddcd345 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodCOF import COFPrimitive class COFSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=COFPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py similarity index 72% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py index 06b793b..5caac2b 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.DeepLog import DeepLogPrimitive class DeepLogSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=DeepLogPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py similarity index 72% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py index 7505cff..347072b 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/Ensemble_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.Ensemble import EnsemblePrimitive class EnsembleSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=EnsemblePrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py index 28b0cb2..7f8c8e0 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodHBOS import HBOSPrimitive class HBOSSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=HBOSPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py similarity index 75% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py index 5e89604..0fabd9d 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodIsolationForest import IsolationForestPrimitiv class IsolationForestSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=IsolationForestPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py similarity index 75% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py index 8d7cd0b..fed6cf7 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.KDiscordODetect import KDiscordODetectorPrimitive class KDiscordODetectorSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=KDiscordODetectorPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py index 74c1c87..47f4c59 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodKNN import KNNPrimitive class KNNSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=KNNPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py index 6565684..c1b40fa 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodLODA import LODAPrimitive class LODASKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=LODAPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py index b6407e9..d9cca8c 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodLOF import LOFPrimitive class LOFSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=LOFPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py similarity index 74% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py index fa3d4b7..cbfb3cf 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.LSTMODetect import LSTMODetectorPrimitive class LSTMODetectorSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=LSTMODetectorPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py similarity index 74% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py index 306fd6d..70126f1 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.MatrixProfile import MatrixProfilePrimitive class MatrixProfileSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=MatrixProfilePrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py similarity index 72% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py index 92cdeb0..8c12c5a 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodMoGaal import Mo_GaalPrimitive class Mo_GaalSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=Mo_GaalPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py similarity index 72% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py index 8bec9e1..b2f2b13 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodOCSVM import OCSVMPrimitive class OCSVMSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=OCSVMPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py similarity index 74% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py index b99155f..e515091 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PCAODetect import PCAODetectorPrimitive class PCAODetectorSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=PCAODetectorPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py similarity index 71% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py index b16dc2c..ee4d2f1 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodSOD import SODPrimitive class SODSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=SODPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py similarity index 72% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py index 576d36a..717466a 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodSoGaal import So_GaalPrimitive class So_GaalSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=So_GaalPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py similarity index 76% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py index bbe042a..90ca9b5 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.SystemWiseDetection import SystemWiseDetectionPrim class SystemWiseDetectionSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=SystemWiseDetectionPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py similarity index 73% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py index 062b3f2..3d9f46f 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.Telemanom import TelemanomPrimitive class TelemanomSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=TelemanomPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py similarity index 75% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py index 0be9451..faf2385 100644 --- a/tods/utils/skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py +++ b/tods/tods_skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py @@ -5,4 +5,6 @@ from tods.detection_algorithm.PyodVAE import VariationalAutoEncoderPrimitive class VariationalAutoEncoderSKI(BaseSKI): def __init__(self, **hyperparams): super().__init__(primitive=VariationalAutoEncoderPrimitive, **hyperparams) - + self.fit_available = True + self.predict_available = True + self.produce_available = False diff --git a/tods/utils/skinterface/primitiveSKI/detection_algorithm/__init__.py b/tods/tods_skinterface/primitiveSKI/detection_algorithm/__init__.py similarity index 100% rename from tods/utils/skinterface/primitiveSKI/detection_algorithm/__init__.py rename to tods/tods_skinterface/primitiveSKI/detection_algorithm/__init__.py diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/AutoCorrelation_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/AutoCorrelation_skinterface.py new file mode 100644 index 0000000..8e7e5c8 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/AutoCorrelation_skinterface.py @@ -0,0 +1,10 @@ +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) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/BKFilter_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/BKFilter_skinterface.py new file mode 100644 index 0000000..ed05521 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/BKFilter_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.BKFilter import BKFilterPrimitive + +class BKFilterSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=BKFilterPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/DiscreteCosineTransform_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/DiscreteCosineTransform_skinterface.py new file mode 100644 index 0000000..f667bb5 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/DiscreteCosineTransform_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.DiscreteCosineTransform import DiscreteCosineTransformPrimitive + +class DiscreteCosineTransformSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=DiscreteCosineTransformPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/FastFourierTransform_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/FastFourierTransform_skinterface.py new file mode 100644 index 0000000..e54fe57 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/FastFourierTransform_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.FastFourierTransform import FastFourierTransformPrimitive + +class FastFourierTransformSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=FastFourierTransformPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/HPFilter_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/HPFilter_skinterface.py new file mode 100644 index 0000000..b137521 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/HPFilter_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.HPFilter import HPFilterPrimitive + +class HPFilterSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=HPFilterPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/NonNegativeMatrixFactorization_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/NonNegativeMatrixFactorization_skinterface.py new file mode 100644 index 0000000..b5a2b7e --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/NonNegativeMatrixFactorization_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.NonNegativeMatrixFactorization import NonNegativeMatrixFactorizationPrimitive + +class NonNegativeMatrixFactorizationSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=NonNegativeMatrixFactorizationPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/SKTruncatedSVD_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/SKTruncatedSVD_skinterface.py new file mode 100644 index 0000000..e0c57a8 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/SKTruncatedSVD_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.SKTruncatedSVD import SKTruncatedSVDPrimitive + +class SKTruncatedSVDSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=SKTruncatedSVDPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/SpectralResidualTransform_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/SpectralResidualTransform_skinterface.py new file mode 100644 index 0000000..dfb9127 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/SpectralResidualTransform_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.SpectralResidualTransform import SpectralResidualTransformPrimitive + +class SpectralResidualTransformSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=SpectralResidualTransformPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsEnergy_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsEnergy_skinterface.py new file mode 100644 index 0000000..9596f54 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsEnergy_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalAbsEnergy import StatisticalAbsEnergyPrimitive + +class StatisticalAbsEnergySKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalAbsEnergyPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsSum_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsSum_skinterface.py new file mode 100644 index 0000000..707dab3 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsSum_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalAbsSum import StatisticalAbsSumPrimitive + +class StatisticalAbsSumSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalAbsSumPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalGmean_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalGmean_skinterface.py new file mode 100644 index 0000000..412e43b --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalGmean_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalGmean import StatisticalGmeanPrimitive + +class StatisticalGmeanSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalGmeanPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalHmean_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalHmean_skinterface.py new file mode 100644 index 0000000..36d9242 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalHmean_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalHmean import StatisticalHmeanPrimitive + +class StatisticalHmeanSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalHmeanPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalKurtosis_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalKurtosis_skinterface.py new file mode 100644 index 0000000..2db67c9 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalKurtosis_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalKurtosis import StatisticalKurtosisPrimitive + +class StatisticalKurtosisSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalKurtosisPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMaximum_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMaximum_skinterface.py new file mode 100644 index 0000000..41f86cf --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMaximum_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMaximum import StatisticalMaximumPrimitive + +class StatisticalMaximumSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMaximumPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbsTemporalDerivative_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbsTemporalDerivative_skinterface.py new file mode 100644 index 0000000..39489eb --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbsTemporalDerivative_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMeanAbsTemporalDerivative import StatisticalMeanAbsTemporalDerivativePrimitive + +class StatisticalMeanAbsTemporalDerivativeSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMeanAbsTemporalDerivativePrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbs_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbs_skinterface.py new file mode 100644 index 0000000..d510f0d --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbs_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMeanAbs import StatisticalMeanAbsPrimitive + +class StatisticalMeanAbsSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMeanAbsPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanTemporalDerivative_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanTemporalDerivative_skinterface.py new file mode 100644 index 0000000..9eb3e23 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanTemporalDerivative_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMeanTemporalDerivative import StatisticalMeanTemporalDerivativePrimitive + +class StatisticalMeanTemporalDerivativeSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMeanTemporalDerivativePrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMean_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMean_skinterface.py new file mode 100644 index 0000000..9fc5e06 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMean_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMean import StatisticalMeanPrimitive + +class StatisticalMeanSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMeanPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedianAbsoluteDeviation_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedianAbsoluteDeviation_skinterface.py new file mode 100644 index 0000000..13a6d57 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedianAbsoluteDeviation_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMedianAbsoluteDeviation import StatisticalMedianAbsoluteDeviationPrimitive + +class StatisticalMedianAbsoluteDeviationSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMedianAbsoluteDeviationPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedian_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedian_skinterface.py new file mode 100644 index 0000000..4b7b8d1 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedian_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMedian import StatisticalMedianPrimitive + +class StatisticalMedianSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMedianPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMinimum_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMinimum_skinterface.py new file mode 100644 index 0000000..d0a40d1 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMinimum_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalMinimum import StatisticalMinimumPrimitive + +class StatisticalMinimumSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalMinimumPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalSkew_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalSkew_skinterface.py new file mode 100644 index 0000000..94321e1 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalSkew_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalSkew import StatisticalSkewPrimitive + +class StatisticalSkewSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalSkewPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalStd_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalStd_skinterface.py new file mode 100644 index 0000000..a586fa2 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalStd_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalStd import StatisticalStdPrimitive + +class StatisticalStdSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalStdPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVar_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVar_skinterface.py new file mode 100644 index 0000000..c683fcc --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVar_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalVar import StatisticalVarPrimitive + +class StatisticalVarSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalVarPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVariation_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVariation_skinterface.py new file mode 100644 index 0000000..38c7b81 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVariation_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalVariation import StatisticalVariationPrimitive + +class StatisticalVariationSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalVariationPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVecSum_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVecSum_skinterface.py new file mode 100644 index 0000000..31a6197 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVecSum_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalVecSum import StatisticalVecSumPrimitive + +class StatisticalVecSumSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalVecSumPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalWillisonAmplitude_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalWillisonAmplitude_skinterface.py new file mode 100644 index 0000000..c03dafe --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalWillisonAmplitude_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalWillisonAmplitude import StatisticalWillisonAmplitudePrimitive + +class StatisticalWillisonAmplitudeSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalWillisonAmplitudePrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalZeroCrossing_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalZeroCrossing_skinterface.py new file mode 100644 index 0000000..4798e17 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalZeroCrossing_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.StatisticalZeroCrossing import StatisticalZeroCrossingPrimitive + +class StatisticalZeroCrossingSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=StatisticalZeroCrossingPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/TRMF_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/TRMF_skinterface.py new file mode 100644 index 0000000..38200d9 --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/TRMF_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.TRMF import TRMFPrimitive + +class TRMFSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=TRMFPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/tods_skinterface/primitiveSKI/feature_analysis/WaveletTransform_skinterface.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/WaveletTransform_skinterface.py new file mode 100644 index 0000000..df4848f --- /dev/null +++ b/tods/tods_skinterface/primitiveSKI/feature_analysis/WaveletTransform_skinterface.py @@ -0,0 +1,10 @@ +import numpy as np +from ..Base_skinterface import BaseSKI +from tods.feature_analysis.WaveletTransform import WaveletTransformPrimitive + +class WaveletTransformSKI(BaseSKI): + def __init__(self, **hyperparams): + super().__init__(primitive=WaveletTransformPrimitive, **hyperparams) + self.fit_available = False + self.predict_available = False + self.produce_available = True diff --git a/tods/utils/skinterface/primitiveSKI/feature_analysis/__init__.py b/tods/tods_skinterface/primitiveSKI/feature_analysis/__init__.py similarity index 100% rename from tods/utils/skinterface/primitiveSKI/feature_analysis/__init__.py rename to tods/tods_skinterface/primitiveSKI/feature_analysis/__init__.py diff --git a/tods/utils/skinterface/primitiveSKI/timeseries_processing/__init__.py b/tods/tods_skinterface/primitiveSKI/timeseries_processing/__init__.py similarity index 100% rename from tods/utils/skinterface/primitiveSKI/timeseries_processing/__init__.py rename to tods/tods_skinterface/primitiveSKI/timeseries_processing/__init__.py diff --git a/tods/utils/skinterface/skinterface_generation.py b/tods/tods_skinterface/script_generation/detection_algorithm_skinterface_generation.py similarity index 83% rename from tods/utils/skinterface/skinterface_generation.py rename to tods/tods_skinterface/script_generation/detection_algorithm_skinterface_generation.py index 9e1a3d1..257e3e2 100644 --- a/tods/utils/skinterface/skinterface_generation.py +++ b/tods/tods_skinterface/script_generation/detection_algorithm_skinterface_generation.py @@ -2,10 +2,10 @@ import re import os -with open('tods/utils/skinterface/entry_points.txt','r',encoding='utf-8') as f: +with open('../entry_points/entry_points_detection_algorithm.txt','r',encoding='utf-8') as f: entry_file = f.read() -output_dir = 'tods/utils/skinterface/primitiveSKI/detection_algorithm' +output_dir = '../primitiveSKI/detection_algorithm' primitive_folder_start_loc_buf = [i.start()+2 for i in re.finditer('=', entry_file)] @@ -28,9 +28,10 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): 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' + class_line2 = primitive_name + ', **hyperparams)\n' + class_line3 = '\t\tself.fit_available = True\n\t\tself.predict_available = True\n\t\tself.produce_available = False\n' - python_content = import_line1 + import_line2 + class_line1 + class_line2 + python_content = import_line1 + import_line2 + class_line1 + class_line2 + class_line3 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) diff --git a/tods/utils/skinterface/main_generation.py b/tods/tods_skinterface/script_generation/detection_algorithm_skitest_generation.py similarity index 88% rename from tods/utils/skinterface/main_generation.py rename to tods/tods_skinterface/script_generation/detection_algorithm_skitest_generation.py index a146f09..19cbb03 100644 --- a/tods/utils/skinterface/main_generation.py +++ b/tods/tods_skinterface/script_generation/detection_algorithm_skitest_generation.py @@ -4,10 +4,10 @@ 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: +with open('../entry_points/entry_points_detection_algorithm.txt','r',encoding='utf-8') as f: entry_file = f.read() -output_dir = 'tods/utils' #output directory +output_dir = '../detection_algorithm_skitest' #output directory primitive_folder_start_loc_buf = [i.start()+2 for i in re.finditer('=', entry_file)] @@ -30,7 +30,7 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf): # sys.path.insert(0, 'tods/utils')""" import_line1 = 'import numpy as np' - import_line2 = '\nfrom skinterface.primitiveSKI.detection_algorithm.'+ primitve_api_name + ' import ' + class_name + '\n\n' + import_line2 = '\nfrom tods.tods_skinterface.primitiveSKI.detection_algorithm.'+ 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]]) @@ -48,7 +48,7 @@ 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') + python_name = primitive_name.replace('Primitive', '_skitest.py') with open(os.path.join(output_dir, python_name), 'w', encoding='utf-8') as f: f.write(python_content) diff --git a/tods/tods_skinterface/script_generation/feature_analysis_skinterface_generation.py b/tods/tods_skinterface/script_generation/feature_analysis_skinterface_generation.py new file mode 100644 index 0000000..8d0b364 --- /dev/null +++ b/tods/tods_skinterface/script_generation/feature_analysis_skinterface_generation.py @@ -0,0 +1,41 @@ + +import re +import os + +with open('../entry_points/entry_points_feature_analysis.txt','r',encoding='utf-8') as f: + entry_file = f.read() + +output_dir = '../primitiveSKI/feature_analysis' + + +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' + class_line3 = '\t\tself.fit_available = False\n\t\tself.predict_available = False\n\t\tself.produce_available = True\n' + + python_content = import_line1 + import_line2 + class_line1 + class_line2 + class_line3 + 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) + + diff --git a/tods/tods_skinterface/script_generation/feature_analysis_skitest_generation.py b/tods/tods_skinterface/script_generation/feature_analysis_skitest_generation.py new file mode 100644 index 0000000..7aa1011 --- /dev/null +++ b/tods/tods_skinterface/script_generation/feature_analysis_skitest_generation.py @@ -0,0 +1,72 @@ +#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('../entry_points/entry_points_feature_analysis.txt','r',encoding='utf-8') as f: + entry_file = f.read() + +output_dir = '../feature_analysis_skitest' #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 tods.tods_skinterface.primitiveSKI.feature_analysis.'+ primitve_api_name + ' import ' + class_name + '\n\n' + #print(import_line) + + main_line1 = """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 = """ +X_transform = transformer.produce(X_test) + +print("Primitive:", transformer.primitive) +print("X_transform:\\n", X_transform) +""" + + python_content = import_line1 + import_line2 + main_line1+main_line2+main_line3 + python_name = primitive_name.replace('Primitive', '_skitest.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/test_api.sh b/tods/tods_skinterface/test_api.sh similarity index 100% rename from tods/utils/skinterface/test_api.sh rename to tods/tods_skinterface/test_api.sh diff --git a/tods/utils/AutoCorrelation_main.py b/tods/utils/AutoCorrelation_main.py deleted file mode 100644 index dedcefa..0000000 --- a/tods/utils/AutoCorrelation_main.py +++ /dev/null @@ -1,11 +0,0 @@ -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) -