FIX KMeansSMOTE: uniform weights for degenerate clusters

When every sample within each valid cluster is identical, all cluster
sparsities are 0, so dividing by their (zero) sum produced NaN weights
and crashed with 'ValueError: cannot convert float NaN to integer' in
math.ceil. Fall back to uniform weighting across the valid clusters.

Closes #1186 (issue 1).

Author: chaoz23

doc/whats_new/v0.15.rst

@@ -11,6 +11,12 @@ Changelog
 Bug fixes
 .........
 
+- Fix a bug in :class:`~imblearn.over_sampling.KMeansSMOTE` where degenerate
+  clusters -- every sample identical, hence zero sparsity -- produced ``NaN``
+  cluster weights and crashed with ``ValueError: cannot convert float NaN to
+  integer``. Such clusters are now weighted uniformly.
+  :pr:`__PRNUM__` by :user:`chaoz23 <chaoz23>`.
+
 Enhancements
 ............
 

imblearn/over_sampling/_smote/cluster.py

@@ -264,7 +264,6 @@ def _fit_resample(self, X, y):
                 cluster_sparsities.append(self._find_cluster_sparsity(X_cluster_class))
 
             cluster_sparsities = np.array(cluster_sparsities)
-            cluster_weights = cluster_sparsities / cluster_sparsities.sum()
 
             if not valid_clusters:
                 raise RuntimeError(
@@ -274,6 +273,19 @@ def _fit_resample(self, X, y):
                     "clusters."
                 )
 
+            sparsity_sum = cluster_sparsities.sum()
+            if sparsity_sum == 0:
+                # All valid clusters are degenerate: every sample within each
+                # cluster is identical, so the pairwise distances -- and hence
+                # the sparsities -- are all zero. Dividing by the (zero) sum
+                # would yield NaN weights and later crash ``math.ceil``. Fall
+                # back to weighting the valid clusters uniformly.
+                cluster_weights = np.full(
+                    len(cluster_sparsities), 1 / len(cluster_sparsities)
+                )
+            else:
+                cluster_weights = cluster_sparsities / sparsity_sum
+
             for valid_cluster_idx, valid_cluster in enumerate(valid_clusters):
                 X_cluster = _safe_indexing(X, valid_cluster)
                 y_cluster = _safe_indexing(y, valid_cluster)

imblearn/over_sampling/_smote/tests/test_kmeans_smote.py

@@ -93,6 +93,27 @@ def test_sample_kmeans_not_enough_clusters(data):
         smote.fit_resample(X, y)
 
 
+def test_sample_kmeans_degenerate_clusters():
+    """Check that identical samples within every valid cluster do not raise.
+
+    Non-regression test for
+    https://github.com/scikit-learn-contrib/imbalanced-learn/issues/1186:
+    when all valid clusters are degenerate (every point identical), their
+    sparsities are all zero and the weights used to be ``NaN``, crashing
+    ``math.ceil`` with ``ValueError: cannot convert float NaN to integer``.
+    """
+    X = np.array([[1.0, 1.0]] * 4 + [[2.0, 2.0]] * 4 + [[3.0, 3.0]] * 4)
+    y = np.array([1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+    smote = KMeansSMOTE(
+        kmeans_estimator=KMeans(n_clusters=2, random_state=42),
+        random_state=42,
+        cluster_balance_threshold=0.1,
+    )
+    X_res, y_res = smote.fit_resample(X, y)
+    # the minority class has been oversampled up to the majority count
+    assert (y_res == 1).sum() == (y_res == 0).sum()
+
+
 @pytest.mark.parametrize("density_exponent", ["auto", 10])
 @pytest.mark.parametrize("cluster_balance_threshold", ["auto", 0.1])
 def test_sample_kmeans_density_estimation(density_exponent, cluster_balance_threshold):