add SK Interface

Former-commit-id: 0cc7b46cb5 [formerly e738376659] [formerly f99af0c9a8 [formerly df1f743cae]] [formerly 0c06626631 [formerly fc045f9a27] [formerly 5c59ed0b9e [formerly 73e36d80a0]]] [formerly 8aea8648b6 [formerly 8987be894c] [formerly 68f1e0618f [formerly 50e44688e2]] [formerly 2634a914ff [formerly 0251808723] [formerly 5d34f5a15e [formerly 1fff6fcae3]]]] [formerly ca44ad09f1 [formerly a33af6d851] [formerly da6f823a2d [formerly f46945c028]] [formerly 8b322fb124 [formerly 73606d900e] [formerly 02a0b89f66 [formerly 77e4113ca2]]] [formerly c3a62ba179 [formerly 9a9aec5e7b] [formerly 052b31817c [formerly 737cbbc4fd]] [formerly d0e9b036cc [formerly c7220995d1] [formerly c9142b33ac [formerly 6284815a6d]]]]] [formerly 529ab3de29 [formerly 928611ef8c] [formerly 5cf5c39c6c [formerly 7d25d5112d]] [formerly 1ad1f6e3e5 [formerly 4dd4c2318d] [formerly 4894af037d [formerly eeb5d9abe7]]] [formerly e5c30ea341 [formerly 40133eb35b] [formerly 8db356c24a [formerly 141570dd05]] [formerly 882a52077f [formerly 414beb9aca] [formerly 631ef99109 [formerly 62c4871d2b]]]] [formerly 57f258afc6 [formerly 32d6986ae5] [formerly 4d2d85cea8 [formerly 8403bf090a]] [formerly 7e514511db [formerly 211285308e] [formerly dbf9db49e1 [formerly 2311de6110]]] [formerly 6741cfe833 [formerly e063bdfc6c] [formerly 385e389c47 [formerly d5876619c5]] [formerly 5062c6d181 [formerly e8ce3c9a2e] [formerly 196443b77d [formerly 93c3a218bb]]]]]]
Former-commit-id: 15b38013d1 [formerly 3d3d71be04] [formerly e0ae1fa058 [formerly 4e81d03f61]] [formerly e368709c7d [formerly 816e97da6f] [formerly 922799dff5 [formerly 58e378ff55]]] [formerly 4e03504c60 [formerly e92bf2f6c8] [formerly db2a97c9f5 [formerly cffbdddb7b]] [formerly ee10f6fbb3 [formerly c44576a258] [formerly 0030f253ec [formerly 836d51e631]]]] [formerly 1e41445ac9 [formerly c24477f990] [formerly c48471a6be [formerly f235ac6c53]] [formerly d6195ecdd5 [formerly 362d5a3c0c] [formerly 72fa47b5ea [formerly 282b48c89b]]] [formerly 15e95cc068 [formerly 7cc03ea195] [formerly 54e79edf1d [formerly 96b5246eed]] [formerly 97ce4ea213 [formerly 69f7624ba0] [formerly 196443b77d]]]]
Former-commit-id: a17db9b00d [formerly 7f87faba19] [formerly 90533d9bcd [formerly 230416679a]] [formerly 03ce031ca1 [formerly 1064d06ece] [formerly 29dc536daf [formerly 9377c6c73e]]] [formerly 424955265f [formerly f5dcd4e757] [formerly 21ffc1f7bf [formerly b11273c577]] [formerly 10d50607d8 [formerly cb2259eddc] [formerly 12779223a4 [formerly 4843981bf3]]]]
Former-commit-id: 10a4361f94 [formerly 257f9f9f4b] [formerly 4bd7491e61 [formerly 1e112cfac2]] [formerly 9a66a35573 [formerly 6ec93e0de2] [formerly 52ddf40fc5 [formerly b2443c01c1]]]
Former-commit-id: 04863097b9 [formerly e1cab2212b] [formerly 05df676cd5 [formerly f7797647a1]]
Former-commit-id: 96ed7ffad3 [formerly 24cdf5f721]
Former-commit-id: c4278ab271

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

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)

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()

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)

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)
+

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)

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)
+

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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'

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

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)
+
+

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)
+

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)
+

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)
+

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)
+

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'

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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)
+

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

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)
+
+

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

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)