iter

imblearn/base.py

@@ -10,11 +10,11 @@
 
 from sklearn.base import BaseEstimator
 from sklearn.preprocessing import label_binarize
-from sklearn.utils.multiclass import check_classification_targets
 
 from .utils import check_sampling_strategy, check_target_type
 from .utils._validation import ArraysTransformer
 from .utils._validation import _deprecate_positional_args
+from .utils.wrapper import check_classification_targets
 
 
 class SamplerMixin(BaseEstimator, metaclass=ABCMeta):
@@ -82,6 +82,7 @@ def fit_resample(self, X, y):
 
         output = self._fit_resample(X, y)
 
+        # TODO: label binarize is not implemented with dask
         y_ = (label_binarize(output[1], np.unique(y))
               if binarize_y else output[1])
 

imblearn/dask/utils.py

@@ -9,7 +9,10 @@ def is_multilabel(y):
     if not (y.ndim == 2 and y.shape[1] > 1):
         return False
 
-    labels = np.unique(y).compute()
+    if hasattr(y, "unique"):
+        labels = np.asarray(y.unique())
+    else:
+        labels = np.unique(y).compute()
 
     return len(labels) < 3 and (
         y.dtype.kind in 'biu' or _is_integral_float(labels)
@@ -39,7 +42,10 @@ def type_of_target(y):
         # NOTE: we don't check for infinite values
         return 'continuous' + suffix
 
-    labels = np.unique(y).compute()
+    if hasattr(y, "unique"):
+        labels = np.asarray(y.unique())
+    else:
+        labels = np.unique(y).compute()
     if (len((labels)) > 2) or (y.ndim >= 2 and len(y[0]) > 1):
         # [1, 2, 3] or [[1., 2., 3]] or [[1, 2]]
         return 'multiclass' + suffix
@@ -63,3 +69,10 @@ def column_or_1d(y, *, warn=False):
     raise ValueError(
         f"y should be a 1d array. Got an array of shape {shape} instead."
     )
+
+
+def check_classification_targets(y):
+    y_type = type_of_target(y)
+    if y_type not in ['binary', 'multiclass', 'multiclass-multioutput',
+                      'multilabel-indicator', 'multilabel-sequences']:
+        raise ValueError("Unknown label type: %r" % y_type)

imblearn/under_sampling/_prototype_selection/_random_under_sampler.py

@@ -81,6 +81,9 @@ def __init__(
         self.replacement = replacement
 
     def _check_X_y(self, X, y):
+        if is_dask_container(y) and hasattr(y, "to_dask_array"):
+            y = y.to_dask_array()
+            y.compute_chunk_sizes()
         y, binarize_y, self._uniques = check_target_type(
             y,
             indicate_one_vs_all=True,
@@ -95,6 +98,9 @@ def _check_X_y(self, X, y):
                 dtype=None,
                 force_all_finite=False,
             )
+        elif is_dask_container(X) and hasattr(X, "to_dask_array"):
+            X = X.to_dask_array()
+            X.compute_chunk_sizes()
         return X, y, binarize_y
 
     @staticmethod
@@ -140,7 +146,7 @@ def _more_tags(self):
                 "2darray",
                 "string",
                 "dask-array",
-                # "dask-dataframe"
+                "dask-dataframe"
             ],
             "sample_indices": True,
             "allow_nan": True,

imblearn/utils/_validation.py

@@ -47,6 +47,9 @@ def transform(self, X, y):
     def _gets_props(self, array):
         props = {}
         props["type"] = array.__class__.__name__
+        if props["type"].lower() in ("series", "dataframe"):
+            suffix = "dask-" if is_dask_container(array) else "pandas-"
+            props["type"] = suffix + props["type"]
         props["columns"] = getattr(array, "columns", None)
         props["name"] = getattr(array, "name", None)
         props["dtypes"] = getattr(array, "dtypes", None)
@@ -56,13 +59,34 @@ def _transfrom_one(self, array, props):
         type_ = props["type"].lower()
         if type_ == "list":
             ret = array.tolist()
-        elif type_ == "dataframe":
+        elif type_ == "pandas-dataframe":
             import pandas as pd
+
             ret = pd.DataFrame(array, columns=props["columns"])
             ret = ret.astype(props["dtypes"])
-        elif type_ == "series":
+        elif type_ == "pandas-series":
             import pandas as pd
+
             ret = pd.Series(array, dtype=props["dtypes"], name=props["name"])
+        elif type_ == "dask-dataframe":
+            from dask import dataframe
+
+            if is_dask_container(array):
+                ret = dataframe.from_dask_array(
+                    array, columns=props["columns"]
+                )
+            else:
+                ret = dataframe.from_array(array, columns=props["columns"])
+            ret = ret.astype(props["dtypes"])
+        elif type_ == "dask-series":
+            from dask import dataframe
+
+            if is_dask_container(array):
+                ret = dataframe.from_dask_array(array)
+            else:
+                ret = dataframe.from_array(array)
+            ret = ret.astype(props["dtypes"])
+            ret = ret.rename(props["name"])
         else:
             ret = array
         return ret

imblearn/utils/estimator_checks.py

@@ -333,6 +333,7 @@ def check_samplers_dask_dataframe(name, sampler):
         X, columns=[str(i) for i in range(X.shape[1])]
     )
     y_s = dask.dataframe.from_array(y)
+    y_s = y_s.rename("target")
 
     X_res_df, y_res_s = sampler.fit_resample(X_df, y_s)
     X_res, y_res = sampler.fit_resample(X, y)
@@ -341,13 +342,11 @@ def check_samplers_dask_dataframe(name, sampler):
     assert isinstance(X_res_df, dask.dataframe.DataFrame)
     assert isinstance(y_res_s, dask.dataframe.Series)
 
-    # assert X_df.columns.to_list() == X_res_df.columns.to_list()
-    # assert y_df.columns.to_list() == y_res_df.columns.to_list()
-    # assert y_s.name == y_res_s.name
+    assert X_df.columns.to_list() == X_res_df.columns.to_list()
+    assert y_s.name == y_res_s.name
 
-    # assert_allclose(X_res_df.to_numpy(), X_res)
-    # assert_allclose(y_res_df.to_numpy().ravel(), y_res)
-    # assert_allclose(y_res_s.to_numpy(), y_res)
+    assert_allclose(np.array(X_res_df), X_res)
+    assert_allclose(np.array(y_res_s), y_res)
 
 
 def check_samplers_list(name, sampler):

imblearn/utils/wrapper.py

@@ -1,5 +1,7 @@
 import numpy as np
 
+from sklearn.utils.multiclass import check_classification_targets as \
+    sklearn_check_classification_targets
 from sklearn.utils.multiclass import type_of_target as sklearn_type_of_target
 from sklearn.utils.validation import column_or_1d as sklearn_column_or_1d
 
@@ -30,8 +32,20 @@ def column_or_1d(y, *, warn=False):
     return sklearn_column_or_1d(y, warn=warn)
 
 
-def unique(*args, **kwargs):
-    output = np.unique(args, kwargs)
-    if is_dask_container(output):
-        return (arr.compute() for arr in output)
-    return output
+def unique(arr, **kwargs):
+    if is_dask_container(arr):
+        if hasattr(arr, "unique"):
+            output = np.asarray(arr.unique(**kwargs))
+        else:
+            output = np.unique(arr).compute()
+        return output
+    return np.unique(arr, **kwargs)
+
+
+def check_classification_targets(y):
+    if is_dask_container(y):
+        from ..dask.utils import check_classification_targets as \
+            dask_check_classification_targets
+
+        return dask_check_classification_targets(y)
+    return sklearn_check_classification_targets(y)