Advance the compatibility with scikit-learn

Author: Guillaume Lemaitre

unbalanced_dataset/base_sampler.py

@@ -3,26 +3,28 @@
 from __future__ import division
 from __future__ import print_function
 
+import warnings
+
 import numpy as np
 
 from abc import ABCMeta, abstractmethod
 
 from collections import Counter
 
+from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.utils import check_X_y
+from sklearn.externals import six
 
 from six import string_types
 
 
-class BaseSampler(object):
+class BaseSampler(six.with_metaclass(ABCMeta, BaseEstimator)):
     """Basic class with abstact method.
 
     Warning: This class should not be used directly. Use the derive classes
     instead.
     """
 
-    __metaclass__ = ABCMeta
-
     @abstractmethod
     def __init__(self, ratio='auto', random_state=None, verbose=True):
         """Initialize this object and its instance variables.
@@ -55,16 +57,16 @@ def __init__(self, ratio='auto', random_state=None, verbose=True):
             elif ratio <= 0:
                 raise ValueError('Ratio cannot be negative.')
             else:
-                self.ratio_ = ratio
+                self.ratio = ratio
         elif isinstance(ratio, string_types):
             if ratio == 'auto':
-                self.ratio_ = ratio
+                self.ratio = ratio
             else:
                 raise ValueError('Unknown string for the parameter ratio.')
         else:
             raise ValueError('Unknown parameter type for ratio.')
 
-        self.rs_ = random_state
+        self.random_state = random_state
         self.verbose = verbose
 
         # Create the member variables regarding the classes statistics
@@ -100,9 +102,13 @@ def fit(self, X, y):
         # Get all the unique elements in the target array
         uniques = np.unique(y)
 
-        # Raise an error if there is only one class
+        # # Raise an error if there is only one class
+        # if uniques.size == 1:
+        #     raise RuntimeError("Only one class detected, aborting...")
+        # Raise a warning for the moment to be compatible with BaseEstimator
         if uniques.size == 1:
-            raise RuntimeError("Only one class detected, aborting...")
+            warnings.warn('Only one class detected, something will get wrong',
+                          RuntimeWarning)
 
         # Create a dictionary containing the class statistics
         self.stats_c_ = Counter(y)
@@ -116,17 +122,17 @@ def fit(self, X, y):
                                                    self.stats_c_))
 
         # Check if the ratio provided at initialisation make sense
-        if isinstance(self.ratio_, float):
-            if self.ratio_ < (self.stats_c_[self.min_c_] /
-                              self.stats_c_[self.maj_c_]):
+        if isinstance(self.ratio, float):
+            if self.ratio < (self.stats_c_[self.min_c_] /
+                             self.stats_c_[self.maj_c_]):
                 raise RuntimeError('The ratio requested at initialisation'
                                    ' should be greater or equal than the'
                                    ' balancing ratio of the current data.')
 
         return self
 
     @abstractmethod
-    def transform(self, X, y):
+    def sample(self, X, y):
         """Resample the dataset.
 
         Parameters
@@ -153,7 +159,7 @@ def transform(self, X, y):
 
         return self
 
-    def fit_transform(self, X, y):
+    def fit_sample(self, X, y):
         """Fit the statistics and resample the data directly.
 
         Parameters
@@ -174,4 +180,4 @@ def fit_transform(self, X, y):
 
         """
 
-        return self.fit(X, y).transform(X, y)
+        return self.fit(X, y).sample(X, y)

unbalanced_dataset/combine/smote_enn.py

@@ -162,15 +162,28 @@ def __init__(self, ratio='auto', random_state=None, verbose=True,
         super(SMOTEENN, self).__init__(ratio=ratio, random_state=random_state,
                                        verbose=verbose)
 
-        self.sm = SMOTE(ratio=ratio, random_state=random_state,
-                        verbose=verbose, k=k, m=m, out_step=out_step,
-                        kind=kind_smote, nn_method=nn_method, n_jobs=n_jobs,
-                        **kwargs)
-
-        self.enn = EditedNearestNeighbours(random_state=random_state,
-                                           verbose=verbose,
-                                           size_ngh=size_ngh,
-                                           kind_sel=kind_enn, n_jobs=n_jobs)
+        self.k = k
+        self.m = m
+        self.out_step = out_step
+        self.kind_smote = kind_smote
+        self.nn_method = nn_method
+        self.n_jobs = n_jobs
+        self.kwargs = kwargs
+
+        self.sm = SMOTE(ratio=self.ratio, random_state=self.random_state,
+                        verbose=self.verbose, k=self.k, m=self.m,
+                        out_step=self.out_step, kind=self.kind_smote,
+                        nn_method=self.nn_method, n_jobs=self.n_jobs,
+                        **self.kwargs)
+
+        self.size_ngh = size_ngh
+        self.kind_enn = kind_enn
+
+        self.enn = EditedNearestNeighbours(random_state=self.random_state,
+                                           verbose=self.verbose,
+                                           size_ngh=self.size_ngh,
+                                           kind_sel=self.kind_enn,
+                                           n_jobs=self.n_jobs)
 
     def fit(self, X, y):
         """Find the classes statistics before to perform sampling.
@@ -199,7 +212,7 @@ def fit(self, X, y):
 
         return self
 
-    def transform(self, X, y):
+    def sample(self, X, y):
         """Resample the dataset.
 
         Parameters
@@ -222,10 +235,10 @@ def transform(self, X, y):
         # Check the consistency of X and y
         X, y = check_X_y(X, y)
 
-        super(SMOTEENN, self).transform(X, y)
+        super(SMOTEENN, self).sample(X, y)
 
         # Transform using SMOTE
-        X, y = self.sm.transform(X, y)
+        X, y = self.sm.sample(X, y)
 
         # Fit and transform using ENN
-        return self.enn.fit_transform(X, y)
+        return self.enn.fit_sample(X, y)

unbalanced_dataset/combine/smote_tomek.py

@@ -150,13 +150,22 @@ def __init__(self, ratio='auto', random_state=None, verbose=True,
                                          random_state=random_state,
                                          verbose=verbose)
 
-        self.sm = SMOTE(ratio=ratio, random_state=random_state,
-                        verbose=verbose, k=k, m=m, out_step=out_step,
-                        kind=kind_smote, nn_method=nn_method, n_jobs=n_jobs,
-                        **kwargs)
-
-        self.tomek = TomekLinks(random_state=random_state,
-                                verbose=verbose)
+        self.k = k
+        self.m = m
+        self.out_step = out_step
+        self.kind_smote = kind_smote
+        self.nn_method = nn_method
+        self.n_jobs = n_jobs
+        self.kwargs = kwargs
+
+        self.sm = SMOTE(ratio=self.ratio, random_state=self.random_state,
+                        verbose=self.verbose, k=self.k, m=self.m,
+                        out_step=self.out_step, kind=self.kind_smote,
+                        nn_method=self.nn_method, n_jobs=self.n_jobs,
+                        **self.kwargs)
+
+        self.tomek = TomekLinks(random_state=self.random_state,
+                                verbose=self.verbose)
 
     def fit(self, X, y):
         """Find the classes statistics before to perform sampling.
@@ -185,7 +194,7 @@ def fit(self, X, y):
 
         return self
 
-    def transform(self, X, y):
+    def sample(self, X, y):
         """Resample the dataset.
 
         Parameters
@@ -208,10 +217,10 @@ def transform(self, X, y):
         # Check the consistency of X and y
         X, y = check_X_y(X, y)
 
-        super(SMOTETomek, self).transform(X, y)
+        super(SMOTETomek, self).sample(X, y)
 
         # Transform using SMOTE
-        X, y = self.sm.transform(X, y)
+        X, y = self.sm.sample(X, y)
 
         # Fit and transform using ENN
-        return self.tomek.fit_transform(X, y)
+        return self.tomek.fit_sample(X, y)

unbalanced_dataset/combine/tests/test_smote_enn.py

@@ -7,8 +7,10 @@
 from numpy.testing import assert_raises
 from numpy.testing import assert_equal
 from numpy.testing import assert_array_equal
+from numpy.testing import assert_warns
 
 from sklearn.datasets import make_classification
+from sklearn.utils.estimator_checks import check_estimator
 
 from unbalanced_dataset.combine import SMOTEENN
 
@@ -20,6 +22,10 @@
                            n_samples=5000, random_state=RND_SEED)
 
 
+def test_senn_sk_estimator():
+    """Test the sklearn estimator compatibility"""
+    check_estimator(SMOTEENN)
+
 def test_senn_bad_ratio():
     """Test either if an error is raised with a wrong decimal value for
     the ratio"""
@@ -49,7 +55,7 @@ def test_smote_fit_single_class():
     # Resample the data
     # Create a wrong y
     y_single_class = np.zeros((X.shape[0], ))
-    assert_raises(RuntimeError, smote.fit, X, y_single_class)
+    assert_warns(RuntimeWarning, smote.fit, X, y_single_class)
 
 
 def test_smote_fit():
@@ -67,24 +73,24 @@ def test_smote_fit():
     assert_equal(smote.stats_c_[1], 4500)
 
 
-def test_smote_transform_wt_fit():
-    """Test either if an error is raised when transform is called before
+def test_smote_sample_wt_fit():
+    """Test either if an error is raised when sample is called before
     fitting"""
 
     # Create the object
     smote = SMOTEENN(random_state=RND_SEED)
-    assert_raises(RuntimeError, smote.transform, X, Y)
+    assert_raises(RuntimeError, smote.sample, X, Y)
 
 
-def test_transform_regular():
-    """Test transform function with regular SMOTE."""
+def test_sample_regular():
+    """Test sample function with regular SMOTE."""
 
     # Create the object
     smote = SMOTEENN(random_state=RND_SEED)
     # Fit the data
     smote.fit(X, Y)
 
-    X_resampled, y_resampled = smote.fit_transform(X, Y)
+    X_resampled, y_resampled = smote.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'smote_enn_reg_x.npy'))
@@ -93,16 +99,16 @@ def test_transform_regular():
     assert_array_equal(y_resampled, y_gt)
 
 
-def test_transform_regular_half():
-    """Test transform function with regular SMOTE and a ratio of 0.5."""
+def test_sample_regular_half():
+    """Test sample function with regular SMOTE and a ratio of 0.5."""
 
     # Create the object
     ratio = 0.5
     smote = SMOTEENN(ratio=ratio, random_state=RND_SEED)
     # Fit the data
     smote.fit(X, Y)
 
-    X_resampled, y_resampled = smote.fit_transform(X, Y)
+    X_resampled, y_resampled = smote.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'smote_enn_reg_x_05.npy'))

unbalanced_dataset/combine/tests/test_smote_tomek.py

@@ -7,8 +7,10 @@
 from numpy.testing import assert_raises
 from numpy.testing import assert_equal
 from numpy.testing import assert_array_equal
+from numpy.testing import assert_warns
 
 from sklearn.datasets import make_classification
+from sklearn.utils.estimator_checks import check_estimator
 
 from unbalanced_dataset.combine import SMOTETomek
 
@@ -20,6 +22,10 @@
                            n_samples=5000, random_state=RND_SEED)
 
 
+def test_smote_sk_estimator():
+    """Test the sklearn estimator compatibility"""
+    check_estimator(SMOTETomek)
+
 def test_smote_bad_ratio():
     """Test either if an error is raised with a wrong decimal value for
     the ratio"""
@@ -49,7 +55,7 @@ def test_smote_fit_single_class():
     # Resample the data
     # Create a wrong y
     y_single_class = np.zeros((X.shape[0], ))
-    assert_raises(RuntimeError, smote.fit, X, y_single_class)
+    assert_warns(RuntimeWarning, smote.fit, X, y_single_class)
 
 
 def test_smote_fit():
@@ -67,24 +73,24 @@ def test_smote_fit():
     assert_equal(smote.stats_c_[1], 4500)
 
 
-def test_smote_transform_wt_fit():
-    """Test either if an error is raised when transform is called before
+def test_smote_sample_wt_fit():
+    """Test either if an error is raised when sample is called before
     fitting"""
 
     # Create the object
     smote = SMOTETomek(random_state=RND_SEED)
-    assert_raises(RuntimeError, smote.transform, X, Y)
+    assert_raises(RuntimeError, smote.sample, X, Y)
 
 
-def test_transform_regular():
-    """Test transform function with regular SMOTE."""
+def test_sample_regular():
+    """Test sample function with regular SMOTE."""
 
     # Create the object
     smote = SMOTETomek(random_state=RND_SEED)
     # Fit the data
     smote.fit(X, Y)
 
-    X_resampled, y_resampled = smote.fit_transform(X, Y)
+    X_resampled, y_resampled = smote.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'smote_tomek_reg_x.npy'))
@@ -93,16 +99,16 @@ def test_transform_regular():
     assert_array_equal(y_resampled, y_gt)
 
 
-def test_transform_regular_half():
-    """Test transform function with regular SMOTE and a ratio of 0.5."""
+def test_sample_regular_half():
+    """Test sample function with regular SMOTE and a ratio of 0.5."""
 
     # Create the object
     ratio = 0.5
     smote = SMOTETomek(ratio=ratio, random_state=RND_SEED)
     # Fit the data
     smote.fit(X, Y)
 
-    X_resampled, y_resampled = smote.fit_transform(X, Y)
+    X_resampled, y_resampled = smote.fit_sample(X, Y)
 
     currdir = os.path.dirname(os.path.abspath(__file__))
     X_gt = np.load(os.path.join(currdir, 'data', 'smote_tomek_reg_x_05.npy'))