Merge pull request #3 from chkoar/deprecation_warning

Deprecation warning

Author: dvro

imblearn/over_sampling/smote.py

@@ -68,6 +68,10 @@ class SMOTE(BaseBinarySampler):
         The type of SMOTE algorithm to use one of the following options:
         'regular', 'borderline1', 'borderline2', 'svm'.
 
+    svm_estimator : object, optional (default=SVC())
+        If `kind='svm'`, a parametrized `sklearn.svm.SVC` classifier can
+        be passed.
+
     n_jobs : int, optional (default=1)
         The number of threads to open if possible.
 
@@ -128,16 +132,16 @@ class SMOTE(BaseBinarySampler):
 
     def __init__(self, ratio='auto', random_state=None, k=None, k_neighbors=5,
                  m=None, m_neighbors=10, out_step=0.5, kind='regular',
-                 n_jobs=1, **kwargs):
+                 svm_estimator=None, n_jobs=1):
         super(SMOTE, self).__init__(ratio=ratio, random_state=random_state)
         self.kind = kind
         self.k = k
         self.k_neighbors = k_neighbors
         self.m = m
         self.m_neighbors = m_neighbors
         self.out_step = out_step
+        self.svm_estimator = svm_estimator
         self.n_jobs = n_jobs
-        self.kwargs = kwargs
 
     def _in_danger_noise(self, samples, y, kind='danger'):
         """Estimate if a set of sample are in danger or noise.
@@ -316,8 +320,13 @@ def _validate_estimator(self):
         # in danger (near the boundary). The level of extrapolation is
         # controled by the out_step.
         if self.kind == 'svm':
-            # Store SVM object with any parameters
-            self.svm = SVC(random_state=self.random_state, **self.kwargs)
+            if self.svm_estimator is None:
+                # Store SVM object with any parameters
+                self.svm_estimator_ = SVC(random_state=self.random_state)
+            elif isinstance(self.svm_estimator, SVC):
+                self.svm_estimator_ = self.svm_estimator
+            else:
+                raise ValueError('`svm_estimator` has to be an SVC object')
 
     def fit(self, X, y):
         """Find the classes statistics before to perform sampling.
@@ -503,11 +512,11 @@ def _sample(self, X, y):
             # belonging to each class.
 
             # Fit SVM to the full data#
-            self.svm.fit(X, y)
+            self.svm_estimator_.fit(X, y)
 
             # Find the support vectors and their corresponding indexes
-            support_index = self.svm.support_[y[self.svm.support_] ==
-                                              self.min_c_]
+            support_index = self.svm_estimator_.support_[
+                y[self.svm_estimator_.support_] == self.min_c_]
             support_vector = X[support_index]
 
             # First, find the nn of all the samples to identify samples

imblearn/over_sampling/tests/test_smote.py

@@ -9,6 +9,7 @@
 from sklearn.datasets import make_classification
 from sklearn.utils.estimator_checks import check_estimator
 from sklearn.neighbors import NearestNeighbors
+from sklearn.svm import SVC
 
 from imblearn.over_sampling import SMOTE
 
@@ -446,3 +447,57 @@ def test_wrong_nn():
                   k_neighbors=nn_k)
 
     assert_raises(ValueError, smote.fit_sample, X, Y)
+
+
+def test_sample_regular_with_nn_svm():
+    """Test sample function with regular SMOTE with a NN object."""
+
+    # Create the object
+    kind = 'svm'
+    nn_k = NearestNeighbors(n_neighbors=6)
+    svm = SVC(random_state=RND_SEED)
+    smote = SMOTE(random_state=RND_SEED, kind=kind,
+                  k_neighbors=nn_k, svm_estimator=svm)
+
+    X_resampled, y_resampled = smote.fit_sample(X, Y)
+
+    X_gt = np.array([[0.11622591, -0.0317206],
+                     [0.77481731, 0.60935141],
+                     [1.25192108, -0.22367336],
+                     [0.53366841, -0.30312976],
+                     [1.52091956, -0.49283504],
+                     [-0.28162401, -2.10400981],
+                     [0.83680821, 1.72827342],
+                     [0.3084254, 0.33299982],
+                     [0.70472253, -0.73309052],
+                     [0.28893132, -0.38761769],
+                     [1.15514042, 0.0129463],
+                     [0.88407872, 0.35454207],
+                     [1.31301027, -0.92648734],
+                     [-1.11515198, -0.93689695],
+                     [-0.18410027, -0.45194484],
+                     [0.9281014, 0.53085498],
+                     [-0.14374509, 0.27370049],
+                     [-0.41635887, -0.38299653],
+                     [0.08711622, 0.93259929],
+                     [1.70580611, -0.11219234],
+                     [0.47436888, -0.2645749],
+                     [1.07844561, -0.19435291],
+                     [1.44015515, -1.30621303]])
+    y_gt = np.array([0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,
+                     0, 0, 0, 0])
+    assert_array_almost_equal(X_resampled, X_gt)
+    assert_array_equal(y_resampled, y_gt)
+
+
+def test_sample_regular_wrong_svm():
+    """Test sample function with regular SMOTE with a NN object."""
+
+    # Create the object
+    kind = 'svm'
+    nn_k = NearestNeighbors(n_neighbors=6)
+    svm = 'rnd'
+    smote = SMOTE(random_state=RND_SEED, kind=kind,
+                  k_neighbors=nn_k, svm_estimator=svm)
+
+    assert_raises(ValueError, smote.fit_sample, X, Y)

imblearn/pipeline.py

@@ -101,7 +101,7 @@ class Pipeline(pipeline.Pipeline):
     >>> X_train, X_test, y_train, y_test = tts(X, y, random_state=42)
     >>> pipeline.fit(X_train, y_train)
     Pipeline(steps=[('smt', SMOTE(k=None, k_neighbors=5, kind='regular', m=None, m_neighbors=10, n_jobs=1,
-       out_step=0.5, random_state=42, ratio='auto')), ('pca', PCA(copy=True, n_components=None, whiten=False)), ('knn', KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
+       out_step=0.5, random_state=42, ratio='auto', svm_estimator=None)), ('pca', PCA(copy=True, n_components=None, whiten=False)), ('knn', KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                metric_params=None, n_jobs=1, n_neighbors=5, p=2,
                weights='uniform'))])
     >>> y_hat = pipeline.predict(X_test)

imblearn/under_sampling/cluster_centroids.py

@@ -35,12 +35,12 @@ class ClusterCentroids(BaseMulticlassSampler):
         If None, the random number generator is the RandomState instance used
         by np.random.
 
+    estimator : object, optional(default=KMeans())
+        Pass a `sklearn.cluster.KMeans` estimator.
+
     n_jobs : int, optional (default=1)
         The number of threads to open if possible.
 
-    **kwargs : keywords
-        Parameter to use for the KMeans object.
-
     Attributes
     ----------
     min_c_ : str or int
@@ -79,11 +79,47 @@ class ClusterCentroids(BaseMulticlassSampler):
 
     """
 
-    def __init__(self, ratio='auto', random_state=None, n_jobs=1, **kwargs):
+    def __init__(self, ratio='auto', random_state=None, estimator=None,
+                 n_jobs=1):
         super(ClusterCentroids, self).__init__(ratio=ratio,
                                                random_state=random_state)
+        self.estimator = estimator
         self.n_jobs = n_jobs
-        self.kwargs = kwargs
+
+    def _validate_estimator(self):
+        """Private function to create the NN estimator"""
+
+        if self.estimator is None:
+            self.estimator_ = KMeans(random_state=self.random_state,
+                                     n_jobs=self.n_jobs)
+        elif isinstance(self.estimator, KMeans):
+            self.estimator_ = self.estimator
+        else:
+            raise ValueError('`estimator` has to be a KMeans clustering.')
+
+    def fit(self, X, y):
+        """Find the classes statistics before to perform sampling.
+
+        Parameters
+        ----------
+        X : ndarray, shape (n_samples, n_features)
+            Matrix containing the data which have to be sampled.
+
+        y : ndarray, shape (n_samples, )
+            Corresponding label for each sample in X.
+
+        Returns
+        -------
+        self : object,
+            Return self.
+
+        """
+
+        super(ClusterCentroids, self).fit(X, y)
+
+        self._validate_estimator()
+
+        return self
 
     def _sample(self, X, y):
         """Resample the dataset.
@@ -105,17 +141,15 @@ def _sample(self, X, y):
             The corresponding label of `X_resampled`
 
         """
-        random_state = check_random_state(self.random_state)
 
         # Compute the number of cluster needed
         if self.ratio == 'auto':
             num_samples = self.stats_c_[self.min_c_]
         else:
             num_samples = int(self.stats_c_[self.min_c_] / self.ratio)
 
-        # Create the clustering object
-        kmeans = KMeans(n_clusters=num_samples, random_state=random_state)
-        kmeans.set_params(**self.kwargs)
+        # Set the number of sample for the estimator
+        self.estimator_.set_params(**{'n_clusters': num_samples})
 
         # Start with the minority class
         X_min = X[y == self.min_c_]
@@ -133,8 +167,8 @@ def _sample(self, X, y):
                 continue
 
             # Find the centroids via k-means
-            kmeans.fit(X[y == key])
-            centroids = kmeans.cluster_centers_
+            self.estimator_.fit(X[y == key])
+            centroids = self.estimator_.cluster_centers_
 
             # Concatenate to the minority class
             X_resampled = np.concatenate((X_resampled, centroids), axis=0)

imblearn/under_sampling/condensed_nearest_neighbour.py

@@ -36,20 +36,18 @@ class CondensedNearestNeighbour(BaseMulticlassSampler):
         NOTE: size_ngh is deprecated from 0.2 and will be replaced in 0.4
         Use ``n_neighbors`` instead.
 
-    n_neighbors : int, optional (default=1)
-        Size of the neighbourhood to consider to compute the average
+    n_neighbors : int or object, optional (default=KNeighborsClassifier(n_neighbors=1))
+        If int, size of the neighbourhood to consider to compute the average
         distance to the minority point samples.
+        If object, an object inherited from
+        `sklearn.neigbors.KNeighborsClassifier` should be passed.
 
     n_seeds_S : int, optional (default=1)
         Number of samples to extract in order to build the set S.
 
     n_jobs : int, optional (default=1)
         The number of threads to open if possible.
 
-    **kwargs : keywords
-        Parameter to use for the Neareast Neighbours object.
-
-
     Attributes
     ----------
     min_c_ : str or int
@@ -95,16 +93,55 @@ class CondensedNearestNeighbour(BaseMulticlassSampler):
     """
 
     def __init__(self, return_indices=False, random_state=None,
-                 size_ngh=None, n_neighbors=1, n_seeds_S=1, n_jobs=1,
-                 **kwargs):
+                 size_ngh=None, n_neighbors=None, n_seeds_S=1, n_jobs=1):
         super(CondensedNearestNeighbour, self).__init__(
             random_state=random_state)
         self.return_indices = return_indices
         self.size_ngh = size_ngh
         self.n_neighbors = n_neighbors
         self.n_seeds_S = n_seeds_S
         self.n_jobs = n_jobs
-        self.kwargs = kwargs
+
+    def _validate_estimator(self):
+        """Private function to create the NN estimator"""
+
+        if self.n_neighbors is None:
+            self.estimator_ = KNeighborsClassifier(
+                n_neighbors=1,
+                n_jobs=self.n_jobs)
+        elif isinstance(self.n_neighbors, int):
+            self.estimator_ = KNeighborsClassifier(
+                n_neighbors=self.n_neighbors,
+                n_jobs=self.n_jobs)
+        elif isinstance(self.n_neighbors, KNeighborsClassifier):
+            self.estimator_ = self.n_neighbors
+        else:
+            raise ValueError('`n_neighbors` has to be a in or an object'
+                             ' inhereited from KNeighborsClassifier.')
+
+    def fit(self, X, y):
+        """Find the classes statistics before to perform sampling.
+
+        Parameters
+        ----------
+        X : ndarray, shape (n_samples, n_features)
+            Matrix containing the data which have to be sampled.
+
+        y : ndarray, shape (n_samples, )
+            Corresponding label for each sample in X.
+
+        Returns
+        -------
+        self : object,
+            Return self.
+
+        """
+
+        super(CondensedNearestNeighbour, self).fit(X, y)
+
+        self._validate_estimator()
+
+        return self
 
     def _sample(self, X, y):
         """Resample the dataset.
@@ -167,13 +204,8 @@ def _sample(self, X, y):
             S_x = X[y == key]
             S_y = y[y == key]
 
-            # Create a k-NN classifier
-            knn = KNeighborsClassifier(n_neighbors=self.n_neighbors,
-                                       n_jobs=self.n_jobs,
-                                       **self.kwargs)
-
             # Fit C into the knn
-            knn.fit(C_x, C_y)
+            self.estimator_.fit(C_x, C_y)
 
             good_classif_label = idx_maj_sample.copy()
             # Check each sample in S if we keep it or drop it
@@ -184,7 +216,7 @@ def _sample(self, X, y):
                     continue
 
                 # Classify on S
-                pred_y = knn.predict(x_sam.reshape(1, -1))
+                pred_y = self.estimator_.predict(x_sam.reshape(1, -1))
 
                 # If the prediction do not agree with the true label
                 # append it in C_x
@@ -198,12 +230,12 @@ def _sample(self, X, y):
                                                     idx_maj_sample.size))
 
                     # Fit C into the knn
-                    knn.fit(C_x, C_y)
+                    self.estimator_.fit(C_x, C_y)
 
                     # This experimental to speed up the search
                     # Classify all the element in S and avoid to test the
                     # well classified elements
-                    pred_S_y = knn.predict(S_x)
+                    pred_S_y = self.estimator_.predict(S_x)
                     good_classif_label = np.unique(
                         np.append(idx_maj_sample,
                                   np.flatnonzero(pred_S_y == S_y)))