1  # -*- coding: utf-8 -*-
  2  
  3  
  4  import os
  5  import sys
  6  import unittest
  7  
  8  # noinspection PyProtectedMember
  9  from sklearn.metrics import roc_auc_score
 10  
 11  # temporary solution for relative imports in case pyod is not installed
 12  # if pyod is installed, no need to use the following line
 13  sys.path.append(
 14      os.path.abspath(os.path.join(os.path.dirname("__file__"), '..')))
 15  sys.path.append(os.path.abspath(os.path.dirname("__file__")))
 16  
 17  from pyod.models.auto_encoder import AutoEncoder
 18  from pyod.utils.data import generate_data
 19  
 20  
 21  class TestAutoEncoder(unittest.TestCase):
 22      def assertHasAttr(self, obj, intended_attr):
 23          self.assertTrue(hasattr(obj, intended_attr))
 24  
 25      def assertInRange(self, data, lower, upper):
 26          self.assertGreaterEqual(data.min(), lower)
 27          self.assertLessEqual(data.max(), upper)
 28  
 29      def setUp(self):
 30          self.n_train = 6000
 31          self.n_test = 1000
 32          self.n_features = 300
 33          self.contamination = 0.1
 34          self.roc_floor = 0.8
 35  
 36          self.X_train, self.X_test, self.y_train, self.y_test = generate_data(
 37              n_train=self.n_train, n_test=self.n_test,
 38              n_features=self.n_features, contamination=self.contamination,
 39              random_state=42)
 40  
 41          self.clf = AutoEncoder(epoch_num=5, contamination=self.contamination)
 42          self.clf.fit(self.X_train)
 43  
 44      def test_parameters(self):
 45          self.assertHasAttr(self.clf, 'decision_scores_')
 46          self.assertIsNotNone(self.clf.decision_scores_)
 47          self.assertHasAttr(self.clf, 'labels_')
 48          self.assertIsNotNone(self.clf.labels_)
 49          self.assertHasAttr(self.clf, 'threshold_')
 50          self.assertIsNotNone(self.clf.threshold_)
 51          self.assertHasAttr(self.clf, '_mu')
 52          self.assertIsNotNone(self.clf._mu)
 53          self.assertHasAttr(self.clf, '_sigma')
 54          self.assertIsNotNone(self.clf._sigma)
 55          self.assertHasAttr(self.clf, 'model')
 56          self.assertIsNotNone(self.clf.model)
 57  
 58      def test_train_scores(self):
 59          self.assertEqual(len(self.clf.decision_scores_), self.X_train.shape[0])
 60  
 61      def test_prediction_scores(self):
 62          pred_scores = self.clf.decision_function(self.X_test)
 63          self.assertEqual(pred_scores.shape[0], self.X_test.shape[0])
 64          self.assertGreaterEqual(roc_auc_score(self.y_test, pred_scores),
 65                                  self.roc_floor)
 66  
 67      def test_prediction_labels(self):
 68          pred_labels = self.clf.predict(self.X_test)
 69          self.assertEqual(pred_labels.shape, self.y_test.shape)
 70  
 71      def test_prediction_proba(self):
 72          pred_proba = self.clf.predict_proba(self.X_test)
 73          self.assertInRange(pred_proba, 0, 1)
 74  
 75      def test_prediction_proba_linear(self):
 76          pred_proba = self.clf.predict_proba(self.X_test, method='linear')
 77          self.assertInRange(pred_proba, 0, 1)
 78  
 79      def test_prediction_proba_unify(self):
 80          pred_proba = self.clf.predict_proba(self.X_test, method='unify')
 81          self.assertInRange(pred_proba, 0, 1)
 82  
 83      def test_prediction_proba_parameter(self):
 84          self.assertRaises(ValueError, self.clf.predict_proba, self.X_test,
 85                            method='something')
 86  
 87      def test_prediction_labels_confidence(self):
 88          pred_labels, confidence = self.clf.predict(self.X_test,
 89                                                     return_confidence=True)
 90          self.assertEqual(pred_labels.shape, self.y_test.shape)
 91          self.assertEqual(confidence.shape, self.y_test.shape)
 92          self.assertInRange(confidence, 0, 1)
 93  
 94      def test_prediction_proba_linear_confidence(self):
 95          pred_proba, confidence = self.clf.predict_proba(self.X_test,
 96                                                          method='linear',
 97                                                          return_confidence=True)
 98          self.assertInRange(pred_proba, 0, 1)
 99          self.assertEqual(confidence.shape, self.y_test.shape)
100          self.assertInRange(confidence, 0, 1)
101  
102      def test_prediction_with_rejection(self):
103          pred_labels = self.clf.predict_with_rejection(self.X_test,
104                                                        return_stats=False)
105          self.assertEqual(pred_labels.shape, self.y_test.shape)
106  
107      def test_prediction_with_rejection_stats(self):
108          _, [expected_rejrate, ub_rejrate,
109              ub_cost] = self.clf.predict_with_rejection(self.X_test,
110                                                         return_stats=True)
111          self.assertGreaterEqual(expected_rejrate, 0)
112          self.assertLessEqual(expected_rejrate, 1)
113          self.assertGreaterEqual(ub_rejrate, 0)
114          self.assertLessEqual(ub_rejrate, 1)
115          self.assertGreaterEqual(ub_cost, 0)
116  
117      def test_fit_predict(self):
118          pred_labels = self.clf.fit_predict(self.X_train)
119          self.assertEqual(pred_labels.shape, self.y_train.shape)
120  
121      def test_fit_predict_score(self):
122          self.clf.fit_predict_score(self.X_test, self.y_test)
123          self.clf.fit_predict_score(self.X_test, self.y_test,
124                                     scoring='roc_auc_score')
125          self.clf.fit_predict_score(self.X_test, self.y_test,
126                                     scoring='prc_n_score')
127          self.assertRaises(NotImplementedError, self.clf.fit_predict_score,
128                            self.X_test, self.y_test, scoring='something')
129  
130      def tearDown(self):
131          pass
132  
133  
134  if __name__ == '__main__':
135      unittest.main()