merged sk_interface with system_wise example. TODO: fix unittest of detection algorithm

examples/sklearn_interface/system_KNN.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from tods.sk_interface.feature_analysis.StatisticalMaximum_skinterface import StatisticalMaximumSKI
+from tods.sk_interface.detection_algorithm.KNN_skinterface import KNNSKI
+from tods.sk_interface.data_ensemble.Ensemble_skinterface import EnsembleSKI
+from tods.sk_interface.utils.data import generate_3D_data, load_sys_data, generate_sys_feature
+
+# Generate 3D data (n, T, d), n: system number, T: time, d: dimension
+
+# n_sys = 5
+# X_train, y_train, X_test, y_test = generate_3D_data(n_sys=n_sys,
+#                                                     n_train=1000,
+#                                                     n_test=1000,
+#                                                     n_features=3,
+#                                                     contamination=0.1)
+
+X_train, y_train, sys_info_train = load_sys_data('../../datasets/anomaly/system_wise/sample/train.csv',
+                                 '../../datasets/anomaly/system_wise/sample/systems')
+X_test, y_test, sys_info_test = load_sys_data('../../datasets/anomaly/system_wise/sample/train.csv',
+                                 '../../datasets/anomaly/system_wise/sample/systems')
+n_sys = sys_info_train['sys_num']
+
+# feature analysis algorithms
+stmax = StatisticalMaximumSKI(system_num=n_sys)
+
+# OD algorithms
+detection_module = KNNSKI(contamination=0.1, system_num=n_sys)
+
+# ensemble model
+ensemble_module = EnsembleSKI()
+
+# Fit the feature analysis algorithms
+X_train = stmax.produce(X_train)
+X_test = stmax.produce(X_test)
+
+# Fit the detector
+detection_module.fit(X_train)
+sys_ts_score = detection_module.predict_score(X_test) # shape (n, T, 1)
+
+# generate sys_feature based on the time-series anomaly score
+sys_feature = generate_sys_feature(sys_ts_score) # shape (T, n)
+
+print(sys_feature.shape)
+print(sys_feature.ndim)
+
+# Ensemble the time series outlier socre for each system
+ensemble_module.fit(sys_feature)
+sys_score = ensemble_module.predict(sys_feature)
+
+print(sys_score)
+

tods/__init__.py

@@ -3,3 +3,4 @@ from tods.data_processing import *
 from tods.timeseries_processing import *
 from tods.feature_analysis import *
 from tods.detection_algorithm import *
+from tods.sk_interface import *

tods/sk_interface/__init__.py

@@ -0,0 +1,3 @@
+from tods.sk_interface.data_ensemble import *
+from tods.sk_interface.feature_analysis import *
+from tods.sk_interface.detection_algorithm import *

tods/sk_interface/base.py

@@ -0,0 +1,142 @@
+from d3m import container
+import numpy as np
+
+def get_default_hyperparameter(primitive, hyperparameter):
+
+    # check if input legal hyperparameter
+    hyperparam_buf = list(primitive.metadata.get_hyperparams().defaults().keys())
+    hyperparam_input = list(hyperparameter.keys())
+    if not set(hyperparam_buf) > set(hyperparam_input):
+        invalid_hyperparam = list(set(hyperparam_input) - set(hyperparam_buf))
+        raise TypeError(primitive.__name__ + ' got unexpected keyword argument ' + str(invalid_hyperparam))
+
+    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)
+
+    return hyperparams
+
+class BaseSKI:
+    def __init__(self, primitive, system_num=1, **hyperparameter):
+
+        self.fit_available = True if 'fit' in primitive.__dict__ else False
+        self.predict_available = True if 'produce' in primitive.__dict__ else False
+        self.predict_score_available = True if 'produce_score' in dir(primitive) else False
+        self.produce_available = True if 'produce' in primitive.__dict__ else False
+
+        # print(primitive, self.fit_available, self.predict_available, self.predict_score_available, self.produce_available)
+
+        self.system_num = system_num
+        hyperparams = get_default_hyperparameter(primitive, hyperparameter)
+
+        if system_num >= 1:
+            self.primitives = [primitive(hyperparams=hyperparams) for sys_idx in range(system_num)]
+        else:
+            raise AttributeError('BaseSKI must have positive system_num.')
+
+
+        #print(hyperparams)
+
+    def fit(self, data):
+
+        if not self.fit_available:
+            raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'fit\'')
+
+        data = self._sys_data_check(data)
+
+        for sys_idx, primitive in enumerate(self.primitives):
+            sys_data = data[sys_idx]
+            sys_data = self._transform(sys_data)
+            primitive.set_training_data(inputs=sys_data)
+            primitive.fit()
+
+        return
+    
+    def predict(self, data):
+
+        if not self.predict_available:
+            raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'predict\'')
+
+        data = self._sys_data_check(data)
+        output_data = self._forward(data, 'produce')
+
+        return output_data
+    
+    def predict_score(self, data):
+
+        if not self.predict_available:
+            raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'predict_score\'')
+
+        data = self._sys_data_check(data)
+        output_data = self._forward(data, 'produce_score')
+
+        return output_data
+
+    def produce(self, data):    #produce function for other primitive types
+
+        if not self.produce_available:
+            raise AttributeError('type object ' + self.__class__.__name__ + ' has no attribute \'produce\'')
+
+        data = self._sys_data_check(data)
+        output_data = self._forward(data, 'produce')
+
+        return output_data
+
+    def _sys_data_check(self, data):
+
+        if self.system_num == 1:
+            if type(data) is np.ndarray and data.ndim == 2:
+                data = [data] # np.expand_dims(data, axis=0)
+            else:
+                raise AttributeError('For system_num = 1, input data should be 2D numpy array.')
+        elif self.system_num > 1:
+            if type(data) is list and len(data) == self.system_num:
+                for ts_data in data:
+                    if type(ts_data) is np.ndarray and ts_data.ndim == 2:
+                        continue
+                    else:
+                        raise AttributeError('For system_num > 1, each element of input list should be 2D numpy arrays.')
+
+            else:
+                raise AttributeError('For system_num > 1, input data should be the list of `system_num` 2D numpy arrays.')
+
+            # if len(data.shape) != 3:
+            #     raise AttributeError('For system_num > 1, input data should have 3 dimensions.')
+            # elif self.system_num != data.shape[0]:
+            #     raise AttributeError('For system_num > 1, data.shape[0] must equal system_num.')
+
+        return data
+
+    def _forward(self, data, method):
+        output_data = []
+        for sys_idx, primitive in enumerate(self.primitives):
+            sys_data = data[sys_idx]
+            sys_data = self._transform(sys_data)
+            forward_method = getattr(primitive, method, None)
+            output_data.append(forward_method(inputs=sys_data).value.values)
+            # print(forward_method(inputs=sys_data).value.values.shape)
+
+        # print(type(output_data), len(output_data), output_data[0].shape)
+        # print(np.array(output_data))
+
+        if self.system_num == 1:
+            output_data = output_data[0]
+
+        # print(np.array(output_data))
+
+        return output_data
+
+        # output_data = np.array(output_data)
+        # if self.system_num == 1:
+        #     output_data = output_data.squeeze(axis=0)
+
+
+    def _transform(self, X):     #transform the ndarray to d3m dataframe, select columns to use
+        column_name = [str(col_index) for col_index in range(X.shape[1])]
+        return container.DataFrame(X, columns=column_name, generate_metadata=True)
+
+    # def set_training_data(self, data):
+    #     return self.primitive.set_training_data(inputs=data)

tods/sk_interface/data_ensemble/Ensemble_skinterface.py

@@ -0,0 +1,43 @@
+import numpy as np 
+from d3m import container
+from tods.detection_algorithm.Ensemble import EnsemblePrimitive
+from ..base import get_default_hyperparameter
+
+class EnsembleSKI:
+	def __init__(self, **hyperparameter):
+
+		hyperparams = get_default_hyperparameter(EnsemblePrimitive, hyperparameter)
+		self.primitive = EnsemblePrimitive(hyperparams=hyperparams)
+
+	def fit(self, data):
+
+		data = self._sys_data_check(data)
+		data = self._transform(data)
+		self.primitive.set_training_data(inputs=data)
+		self.primitive.fit()
+
+		return
+
+	def predict(self, data):
+
+		data = self._sys_data_check(data)
+		data = self._transform(data)
+		output_data = self.primitive.produce(inputs=data).value.values
+
+		return output_data
+
+	def _sys_data_check(self, data):
+
+		if type(data) is np.ndarray and data.ndim == 2 and data.shape[1] == 2:
+			return data
+		else:
+			raise AttributeError('Input data should be n×2 numpy array.')
+
+	def _transform(self, X):
+		column_name = ['timestamp','value','system_id','scores']
+		X = np.concatenate((np.zeros((X.shape[0], 2)), X), axis=1)
+		return container.DataFrame(X, columns=column_name, generate_metadata=True)
+
+	# def __init__(self, **hyperparams):
+	# 	super().__init__(primitive=EnsemblePrimitive, **hyperparams)
+	# 	self.system_num = None

tods/sk_interface/data_ensemble/__init__.py

@@ -0,0 +1 @@
+from tods.sk_interface.data_ensemble.Ensemble_skinterface import EnsembleSKI

tods/tods_skinterface/primitiveSKI/detection_algorithm/ABOD_skinterface.py → tods/sk_interface/detection_algorithm/ABOD_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodABOD import ABODPrimitive
 
 class ABODSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoEncoder_skinterface.py → tods/sk_interface/detection_algorithm/AutoEncoder_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodAE import AutoEncoderPrimitive
 
 class AutoEncoderSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/AutoRegODetector_skinterface.py → tods/sk_interface/detection_algorithm/AutoRegODetector_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.AutoRegODetect import AutoRegODetectorPrimitive
 
 class AutoRegODetectorSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/CBLOF_skinterface.py → tods/sk_interface/detection_algorithm/CBLOF_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodCBLOF import CBLOFPrimitive
 
 class CBLOFSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/COF_skinterface.py → tods/sk_interface/detection_algorithm/COF_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodCOF import COFPrimitive
 
 class COFSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/DeepLog_skinterface.py → tods/sk_interface/detection_algorithm/DeepLog_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.DeepLog import DeepLogPrimitive
 
 class DeepLogSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/HBOS_skinterface.py → tods/sk_interface/detection_algorithm/HBOS_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodHBOS import HBOSPrimitive
 
 class HBOSSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/IsolationForest_skinterface.py → tods/sk_interface/detection_algorithm/IsolationForest_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodIsolationForest import IsolationForestPrimitive
 
 class IsolationForestSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/KDiscordODetector_skinterface.py → tods/sk_interface/detection_algorithm/KDiscordODetector_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.KDiscordODetect import KDiscordODetectorPrimitive
 
 class KDiscordODetectorSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/KNN_skinterface.py → tods/sk_interface/detection_algorithm/KNN_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodKNN import KNNPrimitive
 
 class KNNSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/LODA_skinterface.py → tods/sk_interface/detection_algorithm/LODA_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodLODA import LODAPrimitive
 
 class LODASKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/LOF_skinterface.py → tods/sk_interface/detection_algorithm/LOF_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodLOF import LOFPrimitive
 
 class LOFSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/LSTMODetector_skinterface.py → tods/sk_interface/detection_algorithm/LSTMODetector_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.LSTMODetect import LSTMODetectorPrimitive
 
 class LSTMODetectorSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/MatrixProfile_skinterface.py → tods/sk_interface/detection_algorithm/MatrixProfile_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.MatrixProfile import MatrixProfilePrimitive
 
 class MatrixProfileSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/Mo_Gaal_skinterface.py → tods/sk_interface/detection_algorithm/Mo_Gaal_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodMoGaal import Mo_GaalPrimitive
 
 class Mo_GaalSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/OCSVM_skinterface.py → tods/sk_interface/detection_algorithm/OCSVM_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodOCSVM import OCSVMPrimitive
 
 class OCSVMSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/PCAODetector_skinterface.py → tods/sk_interface/detection_algorithm/PCAODetector_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PCAODetect import PCAODetectorPrimitive
 
 class PCAODetectorSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/SOD_skinterface.py → tods/sk_interface/detection_algorithm/SOD_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodSOD import SODPrimitive
 
 class SODSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/So_Gaal_skinterface.py → tods/sk_interface/detection_algorithm/So_Gaal_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodSoGaal import So_GaalPrimitive
 
 class So_GaalSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/SystemWiseDetection_skinterface.py → tods/sk_interface/detection_algorithm/SystemWiseDetection_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.SystemWiseDetection import SystemWiseDetectionPrimitive
 
 class SystemWiseDetectionSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/detection_algorithm/Telemanom_skinterface.py → tods/sk_interface/detection_algorithm/Telemanom_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.Telemanom import TelemanomPrimitive
 
 class TelemanomSKI(BaseSKI):
@@ -8,4 +8,3 @@ class TelemanomSKI(BaseSKI):
 		self.fit_available = True
 		self.predict_available = True
 		self.produce_available = False
-

tods/tods_skinterface/primitiveSKI/detection_algorithm/VariationalAutoEncoder_skinterface.py → tods/sk_interface/detection_algorithm/VariationalAutoEncoder_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.detection_algorithm.PyodVAE import VariationalAutoEncoderPrimitive
 
 class VariationalAutoEncoderSKI(BaseSKI):

tods/sk_interface/detection_algorithm/__init__.py

@@ -0,0 +1,22 @@
+from tods.sk_interface.detection_algorithm.ABOD_skinterface import ABODSKI
+from tods.sk_interface.detection_algorithm.AutoEncoder_skinterface import AutoEncoderSKI
+from tods.sk_interface.detection_algorithm.AutoRegODetector_skinterface import AutoRegODetectorSKI
+from tods.sk_interface.detection_algorithm.CBLOF_skinterface import CBLOFSKI
+from tods.sk_interface.detection_algorithm.COF_skinterface import COFSKI
+from tods.sk_interface.detection_algorithm.DeepLog_skinterface import DeepLogSKI
+from tods.sk_interface.detection_algorithm.HBOS_skinterface import HBOSSKI
+from tods.sk_interface.detection_algorithm.IsolationForest_skinterface import IsolationForestSKI
+from tods.sk_interface.detection_algorithm.KDiscordODetector_skinterface import KDiscordODetectorSKI
+from tods.sk_interface.detection_algorithm.KNN_skinterface import KNNSKI
+from tods.sk_interface.detection_algorithm.LODA_skinterface import LODASKI
+from tods.sk_interface.detection_algorithm.LOF_skinterface import LOFSKI
+from tods.sk_interface.detection_algorithm.LSTMODetector_skinterface import LSTMODetectorSKI
+from tods.sk_interface.detection_algorithm.MatrixProfile_skinterface import MatrixProfileSKI
+from tods.sk_interface.detection_algorithm.Mo_Gaal_skinterface import Mo_GaalSKI
+from tods.sk_interface.detection_algorithm.OCSVM_skinterface import OCSVMSKI
+from tods.sk_interface.detection_algorithm.PCAODetector_skinterface import PCAODetectorSKI
+from tods.sk_interface.detection_algorithm.SOD_skinterface import SODSKI
+from tods.sk_interface.detection_algorithm.So_Gaal_skinterface import So_GaalSKI
+from tods.sk_interface.detection_algorithm.SystemWiseDetection_skinterface import SystemWiseDetectionSKI
+from tods.sk_interface.detection_algorithm.Telemanom_skinterface import TelemanomSKI
+from tods.sk_interface.detection_algorithm.VariationalAutoEncoder_skinterface import VariationalAutoEncoderSKI

tods/tods_skinterface/primitiveSKI/feature_analysis/AutoCorrelation_skinterface.py → tods/sk_interface/feature_analysis/AutoCorrelation_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.AutoCorrelation import AutoCorrelationPrimitive
 
 class AutoCorrelationSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/BKFilter_skinterface.py → tods/sk_interface/feature_analysis/BKFilter_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.BKFilter import BKFilterPrimitive
 
 class BKFilterSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/DiscreteCosineTransform_skinterface.py → tods/sk_interface/feature_analysis/DiscreteCosineTransform_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.DiscreteCosineTransform import DiscreteCosineTransformPrimitive
 
 class DiscreteCosineTransformSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/FastFourierTransform_skinterface.py → tods/sk_interface/feature_analysis/FastFourierTransform_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.FastFourierTransform import FastFourierTransformPrimitive
 
 class FastFourierTransformSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/HPFilter_skinterface.py → tods/sk_interface/feature_analysis/HPFilter_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.HPFilter import HPFilterPrimitive
 
 class HPFilterSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/NonNegativeMatrixFactorization_skinterface.py → tods/sk_interface/feature_analysis/NonNegativeMatrixFactorization_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.NonNegativeMatrixFactorization import NonNegativeMatrixFactorizationPrimitive
 
 class NonNegativeMatrixFactorizationSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/SKTruncatedSVD_skinterface.py → tods/sk_interface/feature_analysis/SKTruncatedSVD_skinterface.py

@@ -1,10 +1,10 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.SKTruncatedSVD import SKTruncatedSVDPrimitive
 
 class SKTruncatedSVDSKI(BaseSKI):
 	def __init__(self, **hyperparams):
 		super().__init__(primitive=SKTruncatedSVDPrimitive, **hyperparams)
-		self.fit_available = False
+		self.fit_available = True
 		self.predict_available = False
 		self.produce_available = True

tods/tods_skinterface/primitiveSKI/feature_analysis/SpectralResidualTransform_skinterface.py → tods/sk_interface/feature_analysis/SpectralResidualTransform_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.SpectralResidualTransform import SpectralResidualTransformPrimitive
 
 class SpectralResidualTransformSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsEnergy_skinterface.py → tods/sk_interface/feature_analysis/StatisticalAbsEnergy_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalAbsEnergy import StatisticalAbsEnergyPrimitive
 
 class StatisticalAbsEnergySKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalAbsSum_skinterface.py → tods/sk_interface/feature_analysis/StatisticalAbsSum_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalAbsSum import StatisticalAbsSumPrimitive
 
 class StatisticalAbsSumSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalGmean_skinterface.py → tods/sk_interface/feature_analysis/StatisticalGmean_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalGmean import StatisticalGmeanPrimitive
 
 class StatisticalGmeanSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalHmean_skinterface.py → tods/sk_interface/feature_analysis/StatisticalHmean_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalHmean import StatisticalHmeanPrimitive
 
 class StatisticalHmeanSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalKurtosis_skinterface.py → tods/sk_interface/feature_analysis/StatisticalKurtosis_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalKurtosis import StatisticalKurtosisPrimitive
 
 class StatisticalKurtosisSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMaximum_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMaximum_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMaximum import StatisticalMaximumPrimitive
 
 class StatisticalMaximumSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbsTemporalDerivative_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMeanAbsTemporalDerivative_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMeanAbsTemporalDerivative import StatisticalMeanAbsTemporalDerivativePrimitive
 
 class StatisticalMeanAbsTemporalDerivativeSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanAbs_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMeanAbs_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMeanAbs import StatisticalMeanAbsPrimitive
 
 class StatisticalMeanAbsSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMeanTemporalDerivative_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMeanTemporalDerivative_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMeanTemporalDerivative import StatisticalMeanTemporalDerivativePrimitive
 
 class StatisticalMeanTemporalDerivativeSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMean_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMean_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMean import StatisticalMeanPrimitive
 
 class StatisticalMeanSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedianAbsoluteDeviation_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMedianAbsoluteDeviation_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMedianAbsoluteDeviation import StatisticalMedianAbsoluteDeviationPrimitive
 
 class StatisticalMedianAbsoluteDeviationSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMedian_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMedian_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMedian import StatisticalMedianPrimitive
 
 class StatisticalMedianSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalMinimum_skinterface.py → tods/sk_interface/feature_analysis/StatisticalMinimum_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalMinimum import StatisticalMinimumPrimitive
 
 class StatisticalMinimumSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalSkew_skinterface.py → tods/sk_interface/feature_analysis/StatisticalSkew_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalSkew import StatisticalSkewPrimitive
 
 class StatisticalSkewSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalStd_skinterface.py → tods/sk_interface/feature_analysis/StatisticalStd_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalStd import StatisticalStdPrimitive
 
 class StatisticalStdSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVar_skinterface.py → tods/sk_interface/feature_analysis/StatisticalVar_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalVar import StatisticalVarPrimitive
 
 class StatisticalVarSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVariation_skinterface.py → tods/sk_interface/feature_analysis/StatisticalVariation_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalVariation import StatisticalVariationPrimitive
 
 class StatisticalVariationSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalVecSum_skinterface.py → tods/sk_interface/feature_analysis/StatisticalVecSum_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalVecSum import StatisticalVecSumPrimitive
 
 class StatisticalVecSumSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalWillisonAmplitude_skinterface.py → tods/sk_interface/feature_analysis/StatisticalWillisonAmplitude_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalWillisonAmplitude import StatisticalWillisonAmplitudePrimitive
 
 class StatisticalWillisonAmplitudeSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/StatisticalZeroCrossing_skinterface.py → tods/sk_interface/feature_analysis/StatisticalZeroCrossing_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.StatisticalZeroCrossing import StatisticalZeroCrossingPrimitive
 
 class StatisticalZeroCrossingSKI(BaseSKI):

tods/tods_skinterface/primitiveSKI/feature_analysis/TRMF_skinterface.py → tods/sk_interface/feature_analysis/TRMF_skinterface.py

@@ -1,10 +1,10 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.TRMF import TRMFPrimitive
 
 class TRMFSKI(BaseSKI):
 	def __init__(self, **hyperparams):
 		super().__init__(primitive=TRMFPrimitive, **hyperparams)
-		self.fit_available = False
+		self.fit_available = True
 		self.predict_available = False
 		self.produce_available = True

tods/tods_skinterface/primitiveSKI/feature_analysis/WaveletTransform_skinterface.py → tods/sk_interface/feature_analysis/WaveletTransform_skinterface.py

@@ -1,5 +1,5 @@
 import numpy as np 
-from ..Base_skinterface import BaseSKI
+from ..base import BaseSKI
 from tods.feature_analysis.WaveletTransform import WaveletTransformPrimitive
 
 class WaveletTransformSKI(BaseSKI):

tods/sk_interface/feature_analysis/__init__.py

@@ -0,0 +1,30 @@
+from tods.sk_interface.feature_analysis.AutoCorrelation_skinterface import AutoCorrelationSKI
+from tods.sk_interface.feature_analysis.BKFilter_skinterface import BKFilterSKI
+from tods.sk_interface.feature_analysis.DiscreteCosineTransform_skinterface import DiscreteCosineTransformSKI
+from tods.sk_interface.feature_analysis.FastFourierTransform_skinterface import FastFourierTransformSKI
+from tods.sk_interface.feature_analysis.HPFilter_skinterface import HPFilterSKI
+from tods.sk_interface.feature_analysis.NonNegativeMatrixFactorization_skinterface import NonNegativeMatrixFactorizationSKI
+from tods.sk_interface.feature_analysis.SKTruncatedSVD_skinterface import SKTruncatedSVDSKI
+from tods.sk_interface.feature_analysis.SpectralResidualTransform_skinterface import SpectralResidualTransformSKI
+from tods.sk_interface.feature_analysis.StatisticalAbsEnergy_skinterface import StatisticalAbsEnergySKI
+from tods.sk_interface.feature_analysis.StatisticalAbsSum_skinterface import StatisticalAbsSumSKI
+from tods.sk_interface.feature_analysis.StatisticalGmean_skinterface import StatisticalGmeanSKI
+from tods.sk_interface.feature_analysis.StatisticalHmean_skinterface import StatisticalHmeanSKI
+from tods.sk_interface.feature_analysis.StatisticalKurtosis_skinterface import StatisticalKurtosisSKI
+from tods.sk_interface.feature_analysis.StatisticalMaximum_skinterface import StatisticalMaximumSKI
+from tods.sk_interface.feature_analysis.StatisticalMeanAbsTemporalDerivative_skinterface import StatisticalMeanAbsTemporalDerivativeSKI
+from tods.sk_interface.feature_analysis.StatisticalMeanAbs_skinterface import StatisticalMeanAbsSKI
+from tods.sk_interface.feature_analysis.StatisticalMeanTemporalDerivative_skinterface import StatisticalMeanTemporalDerivativeSKI
+from tods.sk_interface.feature_analysis.StatisticalMean_skinterface import StatisticalMeanSKI
+from tods.sk_interface.feature_analysis.StatisticalMedianAbsoluteDeviation_skinterface import StatisticalMedianAbsoluteDeviationSKI
+from tods.sk_interface.feature_analysis.StatisticalMedian_skinterface import StatisticalMedianSKI
+from tods.sk_interface.feature_analysis.StatisticalMinimum_skinterface import StatisticalMinimumSKI
+from tods.sk_interface.feature_analysis.StatisticalSkew_skinterface import StatisticalSkewSKI
+from tods.sk_interface.feature_analysis.StatisticalStd_skinterface import StatisticalStdSKI
+from tods.sk_interface.feature_analysis.StatisticalVar_skinterface import StatisticalVarSKI
+from tods.sk_interface.feature_analysis.StatisticalVariation_skinterface import StatisticalVariationSKI
+from tods.sk_interface.feature_analysis.StatisticalVecSum_skinterface import StatisticalVecSumSKI
+from tods.sk_interface.feature_analysis.StatisticalWillisonAmplitude_skinterface import StatisticalWillisonAmplitudeSKI
+from tods.sk_interface.feature_analysis.StatisticalZeroCrossing_skinterface import StatisticalZeroCrossingSKI
+from tods.sk_interface.feature_analysis.TRMF_skinterface import TRMFSKI
+from tods.sk_interface.feature_analysis.WaveletTransform_skinterface import WaveletTransformSKI

tods/tods_skinterface/script/detection_algorithm_skinterface_generation.py → tods/sk_interface/script/detection_algorithm_skinterface_generation.py

@@ -2,7 +2,7 @@
 import re
 import os
 
-with open('../entry_points/entry_points_detection_algorithm.txt','r',encoding='utf-8') as f:
+with open('../utils/entry_points/entry_points_detection_algorithm.txt','r',encoding='utf-8') as f:
     entry_file = f.read()
 
 output_dir = '../primitiveSKI/detection_algorithm'
@@ -22,7 +22,7 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf):
     # print(entry_file[primitive_folder_start_loc:primitive_start_loc-1])
     # print(entry_file[primitive_start_loc:primitive_end_loc])
 
-    import_line1 = 'import numpy as np \nfrom ..Base_skinterface import BaseSKI\n'
+    import_line1 = 'import numpy as np \nfrom ..base import BaseSKI\n'
     import_line2 = 'from ' + primitive_folder + ' import ' + primitive_name + '\n\n'
     # print(import_line)
 

tods/sk_interface/script/detection_algorithm_skitest_generation.py

@@ -0,0 +1,85 @@
+#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('../utils/entry_points/entry_points_detection_algorithm.txt','r',encoding='utf-8') as f:
+    entry_file = f.read()
+
+output_dir = '../test/detection_algorithm'   #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]
+    algorithm_name = primitive_name.replace('Primitive', '')
+
+    # 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_line1 = """import numpy as np
+import pandas as pd
+import os
+""" + 'from tods.sk_interface.detection_algorithm.'+ primitve_api_name + ' import ' + class_name + '\n\n'
+
+    import_line2 = """from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score\n
+"""
+
+    main_line1 = 'class ' + algorithm_name + 'SKI_TestCase(unittest.TestCase):\n' + \
+"""    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)\n
+"""
+
+    main_line2 = '        self.transformer = ' + class_name + '(contamination=self.contamination)\n        self.transformer.fit(self.X_train)\n\n'
+    main_line3 = """    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()
+"""
+
+    python_content = import_line1 + import_line2 + main_line1+main_line2+main_line3
+    python_name = 'test_ski_' + algorithm_name + '.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)
+
+

tods/tods_skinterface/script/feature_analysis_skinterface_generation.py → tods/sk_interface/script/feature_analysis_skinterface_generation.py

@@ -2,11 +2,12 @@
 import re
 import os
 
-with open('../entry_points/entry_points_feature_analysis.txt','r',encoding='utf-8') as f:
+with open('../utils/entry_points/entry_points_feature_analysis.txt','r',encoding='utf-8') as f:
     entry_file = f.read()
 
 output_dir = '../primitiveSKI/feature_analysis'
 
+fit_available_primitives = ['TRMFPrimitive', 'SKTruncatedSVDPrimitive']
 
 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)]
@@ -22,14 +23,18 @@ for primitive_index, primitive_start_loc in enumerate(primitive_start_loc_buf):
     # print(entry_file[primitive_folder_start_loc:primitive_start_loc-1])
     # print(entry_file[primitive_start_loc:primitive_end_loc])
 
-    import_line1 = 'import numpy as np \nfrom ..Base_skinterface import BaseSKI\n'
+    import_line1 = 'import numpy as np \nfrom ..base import BaseSKI\n'
     import_line2 = 'from ' + primitive_folder + ' import ' + primitive_name + '\n\n'
     # print(import_line)
 
     class_name = primitive_name.replace('Primitive', 'SKI')
     class_line1 = 'class ' + class_name + '(BaseSKI):\n\tdef __init__(self, **hyperparams):\n\t\tsuper().__init__(primitive='
     class_line2 = primitive_name + ', **hyperparams)\n'
-    class_line3 = '\t\tself.fit_available = False\n\t\tself.predict_available = False\n\t\tself.produce_available = True\n'
+
+    if primitive_name in fit_available_primitives:
+        class_line3 = '\t\tself.fit_available = True\n\t\tself.predict_available = False\n\t\tself.produce_available = True\n'
+    else:
+        class_line3 = '\t\tself.fit_available = False\n\t\tself.predict_available = False\n\t\tself.produce_available = True\n'
 
     python_content = import_line1 + import_line2 + class_line1 + class_line2 + class_line3
     python_name = primitive_name.replace('Primitive', '_skinterface.py')

tods/sk_interface/script/feature_analysis_skitest_generation.py

@@ -0,0 +1,84 @@
+#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('../utils/entry_points/entry_points_feature_analysis.txt','r',encoding='utf-8') as f:
+    entry_file = f.read()
+
+output_dir = '../test/feature_analysis'   #output directory
+
+fit_available_primitives = ['SKTruncatedSVDPrimitive']
+
+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]
+    algorithm_name = primitive_name.replace('Primitive', '')
+
+    # 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_line1 = """import numpy as np
+import pandas as pd
+import os
+""" + 'from tods.sk_interface.feature_analysis.' + primitve_api_name + ' import ' + class_name + '\n\n'
+
+    import_line2 = """from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score\n
+"""
+
+    main_line1 = 'class ' + algorithm_name + 'SKI_TestCase(unittest.TestCase):\n' + \
+"""    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)\n
+"""
+
+    main_line2 = '        self.transformer = ' + class_name + '()\n'
+    if primitive_name in fit_available_primitives:
+        main_line3 = '        self.transformer.fit(self.X_train)\n\n'
+    else:
+        main_line3 = '\n'
+
+    main_line4 = """    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()
+"""
+
+    python_content = import_line1 + import_line2 + main_line1+main_line2+main_line3+main_line4
+    python_name = 'test_ski_' + algorithm_name + '.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)
+
+
+

tods/sk_interface/test/detection_algorithm/run_tests.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+import sys
+import unittest
+
+runner = unittest.TextTestRunner(verbosity=1)
+tests = unittest.TestLoader().discover('./')
+if not runner.run(tests).wasSuccessful():
+    sys.exit(1)
+
+#for each in ['data_processing', 'timeseries_processing', 'feature_analysis', 'detection_algorithm']:
+#    tests = unittest.TestLoader().discover(each)
+#    if not runner.run(tests).wasSuccessful():
+#        sys.exit(1)

tods/sk_interface/test/detection_algorithm/test_ski_ABOD.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.ABOD_skinterface import ABODSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class ABODSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = ABODSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_AutoEncoder.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.AutoEncoder_skinterface import AutoEncoderSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class AutoEncoderSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = AutoEncoderSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_AutoRegODetector.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.AutoRegODetector_skinterface import AutoRegODetectorSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class AutoRegODetectorSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = AutoRegODetectorSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_CBLOF.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.CBLOF_skinterface import CBLOFSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class CBLOFSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = CBLOFSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_COF.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.COF_skinterface import COFSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class COFSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = COFSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_DeepLog.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.DeepLog_skinterface import DeepLogSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class DeepLogSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = DeepLogSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_HBOS.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.HBOS_skinterface import HBOSSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class HBOSSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = HBOSSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_IsolationForest.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.IsolationForest_skinterface import IsolationForestSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class IsolationForestSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = IsolationForestSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_KDiscordODetector.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.KDiscordODetector_skinterface import KDiscordODetectorSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class KDiscordODetectorSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = KDiscordODetectorSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_KNN.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.KNN_skinterface import KNNSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class KNNSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = KNNSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_LODA.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.LODA_skinterface import LODASKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class LODASKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = LODASKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_LOF.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.LOF_skinterface import LOFSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class LOFSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = LOFSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_LSTMODetector.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.LSTMODetector_skinterface import LSTMODetectorSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class LSTMODetectorSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = LSTMODetectorSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_MatrixProfile.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.MatrixProfile_skinterface import MatrixProfileSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class MatrixProfileSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = MatrixProfileSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_Mo_Gaal.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.Mo_Gaal_skinterface import Mo_GaalSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class Mo_GaalSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = Mo_GaalSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_OCSVM.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.OCSVM_skinterface import OCSVMSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class OCSVMSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = OCSVMSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_PCAODetector.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.PCAODetector_skinterface import PCAODetectorSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class PCAODetectorSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = PCAODetectorSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_SOD.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.SOD_skinterface import SODSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class SODSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = SODSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_So_Gaal.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.So_Gaal_skinterface import So_GaalSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class So_GaalSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = So_GaalSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_SystemWiseDetection.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.SystemWiseDetection_skinterface import SystemWiseDetectionSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class SystemWiseDetectionSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = SystemWiseDetectionSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_Telemanom.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.Telemanom_skinterface import TelemanomSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class TelemanomSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = TelemanomSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/detection_algorithm/test_ski_VariationalAutoEncoder.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.detection_algorithm.VariationalAutoEncoder_skinterface import VariationalAutoEncoderSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class VariationalAutoEncoderSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.maxDiff = None
+        self.n_train = 200
+        self.n_test = 100
+        self.contamination = 0.1
+        self.roc_floor = 0.0
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+            n_train=self.n_train, n_test=self.n_test,
+            contamination=self.contamination, random_state=42)
+
+        self.transformer = VariationalAutoEncoderSKI(contamination=self.contamination)
+        self.transformer.fit(self.X_train)
+
+    def test_prediction_labels(self):
+        pred_labels = self.transformer.predict(self.X_test)
+        assert_equal(pred_labels.shape[0], self.y_test.shape[0])
+
+    def test_prediction_score(self):
+        pred_scores = self.transformer.predict_score(self.X_test)
+        assert_equal(pred_scores.shape[0], self.y_test.shape[0])
+        assert_greater_equal(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/run_tests.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+import sys
+import unittest
+
+runner = unittest.TextTestRunner(verbosity=1)
+tests = unittest.TestLoader().discover('./')
+if not runner.run(tests).wasSuccessful():
+    sys.exit(1)
+
+#for each in ['data_processing', 'timeseries_processing', 'feature_analysis', 'detection_algorithm']:
+#    tests = unittest.TestLoader().discover(each)
+#    if not runner.run(tests).wasSuccessful():
+#        sys.exit(1)

tods/sk_interface/test/feature_analysis/test_ski_AutoCorrelation.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.AutoCorrelation_skinterface import AutoCorrelationSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class AutoCorrelationSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = AutoCorrelationSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_BKFilter.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.BKFilter_skinterface import BKFilterSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class BKFilterSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = BKFilterSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_DiscreteCosineTransform.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.DiscreteCosineTransform_skinterface import DiscreteCosineTransformSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class DiscreteCosineTransformSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = DiscreteCosineTransformSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_FastFourierTransform.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.FastFourierTransform_skinterface import FastFourierTransformSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class FastFourierTransformSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = FastFourierTransformSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_HPFilter.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.HPFilter_skinterface import HPFilterSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class HPFilterSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = HPFilterSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_NonNegativeMatrixFactorization.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.NonNegativeMatrixFactorization_skinterface import NonNegativeMatrixFactorizationSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class NonNegativeMatrixFactorizationSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = NonNegativeMatrixFactorizationSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_SKTruncatedSVD.py

@@ -0,0 +1,35 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.SKTruncatedSVD_skinterface import SKTruncatedSVDSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class SKTruncatedSVDSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = SKTruncatedSVDSKI()
+        self.transformer.fit(self.X_train)
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_SpectralResidualTransform.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.SpectralResidualTransform_skinterface import SpectralResidualTransformSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class SpectralResidualTransformSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = SpectralResidualTransformSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_StatisticalAbsEnergy.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.StatisticalAbsEnergy_skinterface import StatisticalAbsEnergySKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class StatisticalAbsEnergySKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = StatisticalAbsEnergySKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()

tods/sk_interface/test/feature_analysis/test_ski_StatisticalAbsSum.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+import os
+from tods.sk_interface.feature_analysis.StatisticalAbsSum_skinterface import StatisticalAbsSumSKI
+
+from pyod.utils.data import generate_data
+import unittest
+from sklearn.utils.testing import assert_allclose
+from sklearn.utils.testing import assert_array_less
+from sklearn.utils.testing import assert_equal
+from sklearn.utils.testing import assert_greater
+from sklearn.utils.testing import assert_greater_equal
+from sklearn.utils.testing import assert_less_equal
+from sklearn.utils.testing import assert_raises
+from sklearn.metrics import roc_auc_score
+
+class StatisticalAbsSumSKI_TestCase(unittest.TestCase):
+    def setUp(self):
+
+        self.n_train = 200
+        self.n_test = 100
+        self.X_train, self.y_train, self.X_test, self.y_test = generate_data(
+             n_train=self.n_train, n_test=self.n_test, n_features=5,
+             contamination=0., random_state=42)
+
+        self.transformer = StatisticalAbsSumSKI()
+
+    def test_produce(self):
+        X_transform = self.transformer.produce(self.X_test)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()