added new tests and improved existing tests.

pyod/test/test_abod.py

@@ -7,6 +7,8 @@
 import unittest
 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.metrics import roc_auc_score
 
 from pyod.models.abod import ABOD
@@ -15,7 +17,7 @@
 
 class TestABOD(unittest.TestCase):
     def setUp(self):
-        self.n_train = 100
+        self.n_train = 50
         self.n_test = 50
         self.contamination = 0.1
         self.roc_floor = 0.6
@@ -26,11 +28,20 @@ def setUp(self):
         self.clf = clf = ABOD(contamination=self.contamination)
         self.clf.fit(self.X_train)
 
+    def test_parameters(self):
+        if not hasattr(self.clf,
+                       'decision_scores') or self.clf.decision_scores is None:
+            self.assertRaises(AttributeError, 'decision_scores is not set')
+        if not hasattr(self.clf, 'y_pred') or self.clf.y_pred is None:
+            self.assertRaises(AttributeError, 'y_pred is not set')
+        if not hasattr(self.clf, 'threshold_') or self.clf.threshold_ is None:
+            self.assertRaises(AttributeError, 'threshold_ is not set')
+
     def test_train_scores(self):
         assert_equal(len(self.clf.decision_scores), self.X_train.shape[0])
 
     def test_prediction_scores(self):
-        pred_scores = self.clf.decision_function(self.X_test) * -1
+        pred_scores = self.clf.decision_function(self.X_test)
 
         # check score shapes
         assert_equal(pred_scores.shape[0], self.X_test.shape[0])
@@ -42,6 +53,23 @@ def test_prediction_labels(self):
         pred_labels = self.clf.predict(self.X_test)
         assert_equal(pred_labels.shape, self.y_test.shape)
 
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_fit_predict(self):
+        pred_labels = self.clf.fit_predict(self.X_train)
+        assert_equal(pred_labels.shape, self.y_train.shape)
+
+    def test_evaluate(self):
+        self.clf.evaluate(self.X_test, self.y_test)
+
     def tearDown(self):
         pass
 

pyod/test/test_hbos.py

@@ -7,6 +7,8 @@
 import unittest
 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.metrics import roc_auc_score
 
 from pyod.models.hbos import HBOS
@@ -26,6 +28,19 @@ def setUp(self):
         self.clf = clf = HBOS(contamination=self.contamination)
         self.clf.fit(self.X_train)
 
+    def test_parameters(self):
+        if not hasattr(self.clf,
+                       'decision_scores') or self.clf.decision_scores is None:
+            self.assertRaises(AttributeError, 'decision_scores is not set')
+        if not hasattr(self.clf, 'y_pred') or self.clf.y_pred is None:
+            self.assertRaises(AttributeError, 'y_pred is not set')
+        if not hasattr(self.clf, 'threshold_') or self.clf.threshold_ is None:
+            self.assertRaises(AttributeError, 'threshold_ is not set')
+        if not hasattr(self.clf, 'mu') or self.clf.mu is None:
+            self.assertRaises(AttributeError, 'mu is not set')
+        if not hasattr(self.clf, 'sigma') or self.clf.sigma is None:
+            self.assertRaises(AttributeError, 'sigma is not set')
+
     def test_train_scores(self):
         assert_equal(len(self.clf.decision_scores), self.X_train.shape[0])
 
@@ -42,6 +57,23 @@ def test_prediction_labels(self):
         pred_labels = self.clf.predict(self.X_test)
         assert_equal(pred_labels.shape, self.y_test.shape)
 
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_fit_predict(self):
+        pred_labels = self.clf.fit_predict(self.X_train)
+        assert_equal(pred_labels.shape, self.y_train.shape)
+
+    def test_evaluate(self):
+        self.clf.evaluate(self.X_test, self.y_test)
+
     def tearDown(self):
         pass
 

pyod/test/test_iforest.py

@@ -0,0 +1,87 @@
+import os, sys
+
+# temporary solution for relative imports in case pyod is not installed
+# if pyod is installed, no need to use the following line
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+import unittest
+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.metrics import roc_auc_score
+
+from pyod.models.iforest import IForest
+from pyod.utils.load_data import generate_data
+
+
+class TestIForest(unittest.TestCase):
+    def setUp(self):
+        self.n_train = 100
+        self.n_test = 50
+        self.contamination = 0.1
+        self.roc_floor = 0.6
+        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)
+
+        self.clf = clf = IForest(contamination=self.contamination)
+        self.clf.fit(self.X_train)
+
+    def test_parameters(self):
+        if not hasattr(self.clf,
+                       'decision_scores') or self.clf.decision_scores is None:
+            self.assertRaises(AttributeError, 'decision_scores is not set')
+        if not hasattr(self.clf, 'y_pred') or self.clf.y_pred is None:
+            self.assertRaises(AttributeError, 'y_pred is not set')
+        if not hasattr(self.clf, 'threshold_') or self.clf.threshold_ is None:
+            self.assertRaises(AttributeError, 'threshold_ is not set')
+        if not hasattr(self.clf,
+                       'estimators_') or self.clf.estimators_ is None:
+            self.assertRaises(AttributeError, 'estimators_ is not set')
+        if not hasattr(self.clf,
+                       'estimators_samples_') or self.clf.estimators_samples_ is None:
+            self.assertRaises(AttributeError, 'estimators_samples_ is not set')
+        if not hasattr(self.clf,
+                       'max_samples_') or self.clf.max_samples_ is None:
+            self.assertRaises(AttributeError, 'max_samples_ is not set')
+
+    def test_train_scores(self):
+        assert_equal(len(self.clf.decision_scores), self.X_train.shape[0])
+
+    def test_prediction_scores(self):
+        pred_scores = self.clf.decision_function(self.X_test)
+
+        # check score shapes
+        assert_equal(pred_scores.shape[0], self.X_test.shape[0])
+
+        # check performance
+        assert_greater(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+    def test_prediction_labels(self):
+        pred_labels = self.clf.predict(self.X_test)
+        assert_equal(pred_labels.shape, self.y_test.shape)
+
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_fit_predict(self):
+        pred_labels = self.clf.fit_predict(self.X_train)
+        assert_equal(pred_labels.shape, self.y_train.shape)
+
+    def test_evaluate(self):
+        self.clf.evaluate(self.X_test, self.y_test)
+
+    def tearDown(self):
+        pass
+
+
+if __name__ == '__main__':
+    unittest.main()

pyod/test/test_knn.py

@@ -29,15 +29,16 @@ def setUp(self):
         self.clf.fit(self.X_train)
 
     def test_parameters(self):
-        if not hasattr(self.clf, 'decision_scores'):
+        if not hasattr(self.clf,
+                       'decision_scores') or self.clf.decision_scores is None:
             self.assertRaises(AttributeError, 'decision_scores is not set')
-        if not hasattr(self.clf, 'y_pred'):
+        if not hasattr(self.clf, 'y_pred') or self.clf.y_pred is None:
             self.assertRaises(AttributeError, 'y_pred is not set')
-        if not hasattr(self.clf, 'threshold'):
-            self.assertRaises(AttributeError, 'threshold is not set')
-        if not hasattr(self.clf, 'mu'):
+        if not hasattr(self.clf, 'threshold_') or self.clf.threshold_ is None:
+            self.assertRaises(AttributeError, 'threshold_ is not set')
+        if not hasattr(self.clf, 'mu') or self.clf.mu is None:
             self.assertRaises(AttributeError, 'mu is not set')
-        if not hasattr(self.clf, 'sigma'):
+        if not hasattr(self.clf, 'sigma') or self.clf.sigma is None:
             self.assertRaises(AttributeError, 'sigma is not set')
 
     def test_train_scores(self):
@@ -66,6 +67,13 @@ def test_prediction_proba(self):
         assert_greater_equal(pred_proba.min(), 0)
         assert_less_equal(pred_proba.max(), 1)
 
+    def test_fit_predict(self):
+        pred_labels = self.clf.fit_predict(self.X_train)
+        assert_equal(pred_labels.shape, self.y_train.shape)
+
+    def test_evaluate(self):
+        self.clf.evaluate(self.X_test, self.y_test)
+
     def tearDown(self):
         pass
 

pyod/test/test_lof.py

@@ -0,0 +1,86 @@
+import os, sys
+
+# temporary solution for relative imports in case pyod is not installed
+# if pyod is installed, no need to use the following line
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+import unittest
+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.metrics import roc_auc_score
+
+from pyod.models.lof import LOF
+from pyod.utils.load_data import generate_data
+
+
+class TestLOF(unittest.TestCase):
+    def setUp(self):
+        self.n_train = 100
+        self.n_test = 50
+        self.contamination = 0.1
+        self.roc_floor = 0.6
+        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)
+
+        self.clf = clf = LOF(contamination=self.contamination)
+        self.clf.fit(self.X_train)
+
+    def test_parameters(self):
+        if not hasattr(self.clf,
+                       'decision_scores') or self.clf.decision_scores is None:
+            self.assertRaises(AttributeError, 'decision_scores is not set')
+        if not hasattr(self.clf, 'y_pred') or self.clf.y_pred is None:
+            self.assertRaises(AttributeError, 'y_pred is not set')
+        if not hasattr(self.clf, 'threshold_') or self.clf.threshold_ is None:
+            self.assertRaises(AttributeError, 'threshold_ is not set')
+        if not hasattr(self.clf,
+                       'negative_outlier_factor_') or self.clf.negative_outlier_factor_ is None:
+            self.assertRaises(AttributeError,
+                              'negative_outlier_factor_ is not set')
+
+        if not hasattr(self.clf,
+                       'n_neighbors_') or self.clf.n_neighbors_ is None:
+            self.assertRaises(AttributeError, 'n_neighbors_ is not set')
+
+    def test_train_scores(self):
+        assert_equal(len(self.clf.decision_scores), self.X_train.shape[0])
+
+    def test_prediction_scores(self):
+        pred_scores = self.clf.decision_function(self.X_test)
+
+        # check score shapes
+        assert_equal(pred_scores.shape[0], self.X_test.shape[0])
+
+        # check performance
+        assert_greater(roc_auc_score(self.y_test, pred_scores), self.roc_floor)
+
+    def test_prediction_labels(self):
+        pred_labels = self.clf.predict(self.X_test)
+        assert_equal(pred_labels.shape, self.y_test.shape)
+
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_prediction_proba(self):
+        pred_proba = self.clf.predict_proba(self.X_test)
+        assert_greater_equal(pred_proba.min(), 0)
+        assert_less_equal(pred_proba.max(), 1)
+
+    def test_fit_predict(self):
+        pred_labels = self.clf.fit_predict(self.X_train)
+        assert_equal(pred_labels.shape, self.y_train.shape)
+
+    def test_evaluate(self):
+        self.clf.evaluate(self.X_test, self.y_test)
+
+    def tearDown(self):
+        pass
+
+
+if __name__ == '__main__':
+    unittest.main()