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