Change RENN for scikit-learn compatibility

Author: Guillaume Lemaitre

unbalanced_dataset/under_sampling/edited_nearest_neighbours.py

@@ -376,10 +376,10 @@ def __init__(self, return_indices=False, random_state=None, verbose=True,
             self.max_iter = max_iter
 
         self.enn_ = EditedNearestNeighbours(
-            return_indices=return_indices,
-            random_state=random_state, verbose=False,
-            size_ngh=size_ngh, kind_sel=kind_sel,
-            n_jobs=n_jobs)
+            return_indices=self.return_indices,
+            random_state=self.random_state, verbose=False,
+            size_ngh=self.size_ngh, kind_sel=self.kind_sel,
+            n_jobs=self.n_jobs)
 
     def fit(self, X, y):
         """Find the classes statistics before to perform sampling.
@@ -406,7 +406,7 @@ def fit(self, X, y):
 
         return self
 
-    def transform(self, X, y):
+    def sample(self, X, y):
         """Resample the dataset.
 
         Parameters
@@ -442,10 +442,10 @@ def transform(self, X, y):
         for n_iter in range(self.max_iter):
             prev_len = y_.shape[0]
             if self.return_indices:
-                X_, y_, idx_ = self.enn_.transform(X_, y_)
+                X_, y_, idx_ = self.enn_.sample(X_, y_)
                 idx_under = idx_under[idx_]
             else:
-                X_, y_ = self.enn_.transform(X_, y_)
+                X_, y_ = self.enn_.sample(X_, y_)
 
             if prev_len == y_.shape[0]:
                 break

unbalanced_dataset/under_sampling/tests/test_repeated_edited_nearest_neighbours.py

@@ -22,6 +22,11 @@
                            n_samples=5000, random_state=RND_SEED)
 
 
+def test_enn_sk_estimator():
+    """Test the sklearn estimator compatibility"""
+    check_estimator(RepeatedEditedNearestNeighbours)
+
+
 def test_renn_init():
     """Test the initialisation of the object"""
 
@@ -33,13 +38,23 @@ def test_renn_init():
     assert_equal(renn.size_ngh, 3)
     assert_equal(renn.kind_sel, 'all')
     assert_equal(renn.n_jobs, -1)
-    assert_equal(renn.rs_, RND_SEED)
+    assert_equal(renn.random_state, RND_SEED)
     assert_equal(renn.verbose, verbose)
     assert_equal(renn.min_c_, None)
     assert_equal(renn.maj_c_, None)
     assert_equal(renn.stats_c_, {})
 
 
+def test_renn_iter_wrong():
+    """Test either if an error is raised when the numbr of iteration
+    is wrong"""
+
+    # Create the object
+    max_iter = -1
+    assert_raises(ValueError, RepeatedEditedNearestNeighbours,
+                  max_iter=max_iter, random_state=RND_SEED)
+
+
 def test_renn_fit_single_class():
     """Test either if an error when there is a single class"""
 
@@ -48,7 +63,7 @@ def test_renn_fit_single_class():
     # Resample the data
     # Create a wrong y
     y_single_class = np.zeros((X.shape[0], ))
-    assert_raises(RuntimeError, renn.fit, X, y_single_class)
+    assert_warns(RuntimeWarning, renn.fit, X, y_single_class)
 
 
 def test_renn_fit():
@@ -66,21 +81,21 @@ def test_renn_fit():
     assert_equal(renn.stats_c_[1], 4500)
 
 
-def test_renn_transform_wt_fit():
-    """Test either if an error is raised when transform is called before
+def test_renn_sample_wt_fit():
+    """Test either if an error is raised when sample is called before
     fitting"""
 
     # Create the object
     renn = RepeatedEditedNearestNeighbours(random_state=RND_SEED)
-    assert_raises(RuntimeError, renn.transform, X, Y)
+    assert_raises(RuntimeError, renn.sample, X, Y)
 
 
-def test_renn_fit_transform():
-    """Test the fit transform routine"""
+def test_renn_fit_sample():
+    """Test the fit sample routine"""
 
     # Resample the data
     renn = RepeatedEditedNearestNeighbours(random_state=RND_SEED)
-    X_resampled, y_resampled = renn.fit_transform(X, Y)
+    X_resampled, y_resampled = renn.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'renn_x.npy'))
@@ -89,13 +104,13 @@ def test_renn_fit_transform():
     assert_array_equal(y_resampled, y_gt)
 
 
-def test_renn_fit_transform_with_indices():
-    """Test the fit transform routine with indices support"""
+def test_renn_fit_sample_with_indices():
+    """Test the fit sample routine with indices support"""
 
     # Resample the data
     renn = RepeatedEditedNearestNeighbours(return_indices=True,
                                            random_state=RND_SEED)
-    X_resampled, y_resampled, idx_under = renn.fit_transform(X, Y)
+    X_resampled, y_resampled, idx_under = renn.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'renn_x.npy'))
@@ -106,13 +121,13 @@ def test_renn_fit_transform_with_indices():
     assert_array_equal(idx_under, idx_gt)
 
 
-def test_renn_fit_transform_mode():
-    """Test the fit transform routine using the mode as selection"""
+def test_renn_fit_sample_mode():
+    """Test the fit sample routine using the mode as selection"""
 
     # Resample the data
     renn = RepeatedEditedNearestNeighbours(random_state=RND_SEED,
                                            kind_sel='mode')
-    X_resampled, y_resampled = renn.fit_transform(X, Y)
+    X_resampled, y_resampled = renn.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'renn_x_mode.npy'))