Add sample weight #minor (#56)

* Add ray to tests

* Add sample_weight parameter

Author: mirand863

.github/workflows/deploy-pypi.yml

@@ -28,6 +28,7 @@ jobs:
         python -m pip install pytest-flake8==1.1.1
         python -m pip install pytest-pydocstyle==2.3.0
         python -m pip install pytest-cov==3.0.0
+        python -m pip install ray==1.13.0
         python -m pip install .
     - name: Test with pytest
       run: |

.github/workflows/test-pr.yml

@@ -29,6 +29,7 @@ jobs:
         python -m pip install pytest-flake8==1.1.1
         python -m pip install pytest-pydocstyle==2.3.0
         python -m pip install pytest-cov==3.0.0
+        python -m pip install ray==1.13.0
         python -m pip install .
     - name: Test with pytest
       run: |

hiclass/BinaryPolicy.py

@@ -13,7 +13,9 @@ class BinaryPolicy(ABC):
     Every policy should implement the methods positive_examples and negative_examples.
     """
 
-    def __init__(self, digraph: nx.DiGraph, X: np.ndarray, y: np.ndarray):
+    def __init__(
+        self, digraph: nx.DiGraph, X: np.ndarray, y: np.ndarray, sample_weight=None
+    ):
         """
         Initialize a BinaryPolicy with the required data.
 
@@ -26,10 +28,14 @@ def __init__(self, digraph: nx.DiGraph, X: np.ndarray, y: np.ndarray):
         y : np.ndarray
             Labels which will be assigned to the different samples.
             Has to be 2D array.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual samples.
+            If not provided, then each sample is given unit weight.
         """
         self.digraph = digraph
         self.X = X
         self.y = y
+        self.sample_weight = sample_weight
 
     def positive_examples(self, node) -> np.ndarray:
         """
@@ -128,15 +134,35 @@ def get_binary_examples(self, node) -> tuple:
         negative_examples = self.negative_examples(node)
         positive_x = self.X[positive_examples]
         negative_x = self.X[negative_examples]
+        positive_weights = (
+            self.sample_weight[positive_examples]
+            if self.sample_weight is not None
+            else None
+        )
+        negative_weights = (
+            self.sample_weight[negative_examples]
+            if self.sample_weight is not None
+            else None
+        )
         if isinstance(self.X, np.ndarray):
             X = np.concatenate([positive_x, negative_x])
+            sample_weights = (
+                np.concatenate([positive_weights, negative_weights])
+                if self.sample_weight is not None
+                else None
+            )
             y = np.zeros(len(X))
             y[: len(positive_x)] = 1
         elif isinstance(self.X, csr_matrix):
             X = vstack([positive_x, negative_x])
+            sample_weights = (
+                vstack([positive_weights, negative_weights])
+                if self.sample_weight is not None
+                else None
+            )
             y = np.zeros(X.shape[0])
             y[: positive_x.shape[0]] = 1
-        return X, y
+        return X, y, sample_weights
 
 
 class ExclusivePolicy(BinaryPolicy):

hiclass/ConstantClassifier.py

@@ -5,7 +5,7 @@
 class ConstantClassifier:
     """A classifier that always returns the only label seen during fit."""
 
-    def fit(self, X, y):
+    def fit(self, X, y, sample_weight=None):
         """
         Fit a constant classifier.
 
@@ -17,6 +17,9 @@ def fit(self, X, y):
             converted into a sparse ``csc_matrix``.
         y : array-like of shape (n_samples, n_levels)
             The target values, i.e., hierarchical class labels for classification.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual samples.
+            If not provided, then each sample is given unit weight.
 
         Returns
         -------

hiclass/HierarchicalClassifier.py

@@ -7,6 +7,7 @@
 from joblib import Parallel, delayed
 from sklearn.base import BaseEstimator
 from sklearn.linear_model import LogisticRegression
+from sklearn.utils.validation import _check_sample_weight
 
 try:
     import ray
@@ -96,7 +97,7 @@ def __init__(
         self.n_jobs = n_jobs
         self.classifier_abbreviation = classifier_abbreviation
 
-    def fit(self, X, y):
+    def fit(self, X, y, sample_weight=None):
         """
         Fit a local hierarchical classifier.
 
@@ -110,6 +111,9 @@ def fit(self, X, y):
             converted into a sparse ``csc_matrix``.
         y : array-like of shape (n_samples, n_levels)
             The target values, i.e., hierarchical class labels for classification.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual samples.
+            If not provided, then each sample is given unit weight.
 
         Returns
         -------
@@ -122,14 +126,19 @@ def fit(self, X, y):
         # Delete unnecessary variables
         self._clean_up()
 
-    def _pre_fit(self, X, y):
+    def _pre_fit(self, X, y, sample_weight):
         # Check that X and y have correct shape
         # and convert them to np.ndarray if need be
 
         self.X_, self.y_ = self._validate_data(
             X, y, multi_output=True, accept_sparse="csr"
         )
 
+        if sample_weight is not None:
+            self.sample_weight_ = _check_sample_weight(sample_weight, X)
+        else:
+            self.sample_weight_ = None
+
         self.y_ = make_leveled(self.y_)
 
         # Create and configure logger
@@ -329,3 +338,5 @@ def _clean_up(self):
         self.logger_.info("Cleaning up variables that can take a lot of disk space")
         del self.X_
         del self.y_
+        if self.sample_weight_ is not None:
+            del self.sample_weight_

hiclass/LocalClassifierPerLevel.py

@@ -78,7 +78,7 @@ def __init__(
             classifier_abbreviation="LCPL",
         )
 
-    def fit(self, X, y):
+    def fit(self, X, y, sample_weight=None):
         """
         Fit a local classifier per level.
 
@@ -90,14 +90,17 @@ def fit(self, X, y):
             converted into a sparse ``csc_matrix``.
         y : array-like of shape (n_samples, n_levels)
             The target values, i.e., hierarchical class labels for classification.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual samples.
+            If not provided, then each sample is given unit weight.
 
         Returns
         -------
         self : object
             Fitted estimator.
         """
         # Execute common methods necessary before fitting
-        super()._pre_fit(X, y)
+        super()._pre_fit(X, y, sample_weight)
 
         # Fit local classifiers in DAG
         super().fit(X, y)
@@ -232,17 +235,22 @@ def _fit_digraph(self, local_mode: bool = False, use_joblib: bool = False):
     def _fit_classifier(self, level, separator):
         classifier = self.local_classifiers_[level]
 
-        X, y = self._remove_empty_leaves(separator, self.X_, self.y_[:, level])
+        X, y, sample_weight = self._remove_empty_leaves(
+            separator, self.X_, self.y_[:, level], self.sample_weight_
+        )
 
         unique_y = np.unique(y)
         if len(unique_y) == 1 and self.replace_classifiers:
             classifier = ConstantClassifier()
-        classifier.fit(X, y)
+        classifier.fit(X, y, sample_weight)
         return classifier
 
     @staticmethod
-    def _remove_empty_leaves(separator, X, y):
+    def _remove_empty_leaves(separator, X, y, sample_weight):
         # Detect rows where leaves are not empty
         leaves = np.array([str(i).split(separator)[-1] for i in y])
         mask = leaves != ""
-        return X[mask], y[mask]
+        X = X[mask]
+        y = y[mask]
+        sample_weight = sample_weight[mask] if sample_weight is not None else None
+        return X, y, sample_weight

hiclass/LocalClassifierPerNode.py

@@ -85,7 +85,7 @@ def __init__(
         )
         self.binary_policy = binary_policy
 
-    def fit(self, X, y):
+    def fit(self, X, y, sample_weight=None):
         """
         Fit a local classifier per node.
 
@@ -97,14 +97,17 @@ def fit(self, X, y):
             converted into a sparse ``csc_matrix``.
         y : array-like of shape (n_samples, n_levels)
             The target values, i.e., hierarchical class labels for classification.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual samples.
+            If not provided, then each sample is given unit weight.
 
         Returns
         -------
         self : object
             Fitted estimator.
         """
         # Execute common methods necessary before fitting
-        super()._pre_fit(X, y)
+        super()._pre_fit(X, y, sample_weight)
 
         # Initialize policy
         self._initialize_binary_policy()
@@ -192,7 +195,7 @@ def _initialize_binary_policy(self):
             try:
                 self.binary_policy_ = BinaryPolicy.IMPLEMENTED_POLICIES[
                     self.binary_policy.lower()
-                ](self.hierarchy_, self.X_, self.y_)
+                ](self.hierarchy_, self.X_, self.y_, self.sample_weight_)
             except KeyError:
                 self.logger_.error(
                     f"Policy {self.binary_policy} not implemented. Available policies are:\n"
@@ -226,11 +229,11 @@ def _fit_digraph(self, local_mode: bool = False, use_joblib: bool = False):
     @staticmethod
     def _fit_classifier(self, node):
         classifier = self.hierarchy_.nodes[node]["classifier"]
-        X, y = self.binary_policy_.get_binary_examples(node)
+        X, y, sample_weight = self.binary_policy_.get_binary_examples(node)
         unique_y = np.unique(y)
         if len(unique_y) == 1 and self.replace_classifiers:
             classifier = ConstantClassifier()
-        classifier.fit(X, y)
+        classifier.fit(X, y, sample_weight)
         return classifier
 
     def _clean_up(self):

hiclass/LocalClassifierPerParentNode.py

@@ -71,7 +71,7 @@ def __init__(
             classifier_abbreviation="LCPPN",
         )
 
-    def fit(self, X, y):
+    def fit(self, X, y, sample_weight=None):
         """
         Fit a local classifier per parent node.
 
@@ -83,14 +83,17 @@ def fit(self, X, y):
             converted into a sparse ``csc_matrix``.
         y : array-like of shape (n_samples, n_levels)
             The target values, i.e., hierarchical class labels for classification.
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual samples.
+            If not provided, then each sample is given unit weight.
 
         Returns
         -------
         self : object
             Fitted estimator.
         """
         # Execute common methods necessary before fitting
-        super()._pre_fit(X, y)
+        super()._pre_fit(X, y, sample_weight)
 
         # Fit local classifiers in DAG
         super().fit(X, y)
@@ -187,17 +190,20 @@ def _get_successors(self, node):
             else:
                 y.append(row[np.where(row == node)[0][0] + 1])
         y = np.array(y)
-        return X, y
+        sample_weight = (
+            self.sample_weight_[mask] if self.sample_weight_ is not None else None
+        )
+        return X, y, sample_weight
 
     @staticmethod
     def _fit_classifier(self, node):
         classifier = self.hierarchy_.nodes[node]["classifier"]
         # get children examples
-        X, y = self._get_successors(node)
+        X, y, sample_weight = self._get_successors(node)
         unique_y = np.unique(y)
         if len(unique_y) == 1 and self.replace_classifiers:
             classifier = ConstantClassifier()
-        classifier.fit(X, y)
+        classifier.fit(X, y, sample_weight)
         return classifier
 
     def _fit_digraph(self, local_mode: bool = False, use_joblib: bool = False):