libmultilabel 0.7.3__tar.gz → 0.8.0__tar.gz

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: libmultilabel
-Version: 0.7.3
+Version: 0.8.0
 Summary: A library for multi-class and multi-label classification
 Home-page: https://github.com/ASUS-AICS/LibMultiLabel
 Author: LibMultiLabel Team
@@ -16,22 +16,25 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
 License-File: LICENSE
 Requires-Dist: liblinear-multicore>=2.49.0
 Requires-Dist: numba
 Requires-Dist: pandas>1.3.0
 Requires-Dist: PyYAML
 Requires-Dist: scikit-learn
-Requires-Dist: scipy<1.14.0
+Requires-Dist: scipy
 Requires-Dist: tqdm
+Requires-Dist: psutil
+Requires-Dist: sparsekmeans
 Provides-Extra: nn
-Requires-Dist: lightning==2.0.9; extra == "nn"
+Requires-Dist: lightning; extra == "nn"
 Requires-Dist: nltk; extra == "nn"
 Requires-Dist: torch<=2.3; extra == "nn"
 Requires-Dist: torchmetrics==0.10.3; extra == "nn"
 Requires-Dist: torchtext; extra == "nn"
-Requires-Dist: transformers; extra == "nn"
+Requires-Dist: transformers<=4.51.3; extra == "nn"
+Dynamic: license-file
 
 See documentation here: https://www.csie.ntu.edu.tw/~cjlin/libmultilabel

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/README.md

@@ -9,7 +9,7 @@ LibMultiLabel is a library for binary, multi-class, and multi-label classificati
 This is an on-going development so many improvements are still being made. Comments are very welcome.
 
 ## Environments
-- Python: 3.8+
+- Python: 3.10+
 - CUDA: 11.8, 12.1 (if training neural networks by GPU)
 - Pytorch: 2.0.1+
 

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/libmultilabel/linear/linear.py

@@ -27,7 +27,7 @@ class FlatModel:
     def __init__(
         self,
         name: str,
-        weights: np.matrix,
+        weights: np.matrix | sparse.csr_matrix,
         bias: float,
         thresholds: float | np.ndarray,
         multiclass: bool,
@@ -69,7 +69,21 @@ class FlatModel:
                 "csr",
             )
 
-        return (x * self.weights).A + self.thresholds
+        return self._to_dense_array(x * self.weights) + self.thresholds
+
+    def _to_dense_array(self, matrix: np.matrix | sparse.csr_matrix) -> np.ndarray:
+        """Convert a numpy or scipy matrix to a dense ndarray.
+
+        Args:
+            matrix (np.matrix | sparse.csr_matrix): A numpy or scipy sparse matrix.
+
+        Returns:
+            np.ndarray: A dense ndarray of `matrix`.
+        """
+        if sparse.issparse(matrix):
+            return matrix.toarray()
+        elif isinstance(matrix, np.matrix):
+            return np.asarray(matrix)
 
 
 def train_1vsrest(
@@ -458,7 +472,7 @@ def _cost_sensitive_one_label(y: np.ndarray, x: sparse.csr_matrix, options: str)
 
     param_space = [1, 1.33, 1.8, 2.5, 3.67, 6, 13]
 
-    bestScore = -np.Inf
+    bestScore = -np.inf
     for a in param_space:
         cv_options = f"{options} -w1 {a}"
         pred = _cross_validate(y, x, cv_options, perm)
@@ -532,7 +546,7 @@ def train_cost_sensitive_micro(
     l = y.shape[0]
     perm = np.random.permutation(l)
     param_space = [1, 1.33, 1.8, 2.5, 3.67, 6, 13]
-    bestScore = -np.Inf
+    bestScore = -np.inf
 
     if verbose:
         logging.info(f"Training cost-sensitive model for Micro-F1 on {num_class} labels")

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/libmultilabel/linear/tree.py

@@ -4,7 +4,7 @@ from typing import Callable
 
 import numpy as np
 import scipy.sparse as sparse
-import sklearn.cluster
+from sparsekmeans import LloydKmeans, ElkanKmeans
 import sklearn.preprocessing
 from tqdm import tqdm
 import psutil
@@ -46,13 +46,14 @@ class TreeModel:
         self,
         root: Node,
         flat_model: linear.FlatModel,
-        weight_map: np.ndarray,
+        node_ptr: np.ndarray,
     ):
         self.name = "tree"
         self.root = root
         self.flat_model = flat_model
-        self.weight_map = weight_map
+        self.node_ptr = node_ptr
         self.multiclass = False
+        self._model_separated = False # Indicates whether the model has been separated for pruning tree.
 
     def predict_values(
         self,
@@ -68,10 +69,93 @@ class TreeModel:
         Returns:
             np.ndarray: A matrix with dimension number of instances * number of classes.
         """
-        # number of instances * number of labels + total number of metalabels
-        all_preds = linear.predict_values(self.flat_model, x)
+        if beam_width >= len(self.root.children):
+            # Beam_width is sufficiently large; pruning not applied.
+            # Calculates decision values for all nodes.
+            all_preds = linear.predict_values(self.flat_model, x) # number of instances * (number of labels + total number of metalabels)
+        else:
+            # Beam_width is small; pruning applied to reduce computation.
+            if not self._model_separated:
+                self._separate_model_for_pruning_tree()
+                self._model_separated = True
+            all_preds = self._prune_tree_and_predict_values(x, beam_width) # number of instances * (number of labels + total number of metalabels)
         return np.vstack([self._beam_search(all_preds[i], beam_width) for i in range(all_preds.shape[0])])
 
+    def _separate_model_for_pruning_tree(self):
+        """
+        This function separates the weights for the root node and its children into (K+1) FlatModel
+        for efficient beam search traversal in Python.
+        """
+        tree_flat_model_params = {
+            'bias': self.root.model.bias,
+            'thresholds': 0,
+            'multiclass': False
+        }
+        slice = np.s_[:, self.node_ptr[self.root.index] : self.node_ptr[self.root.index + 1]]
+        self.root_model = linear.FlatModel(
+            name="root-flattened-tree",
+            weights=self.flat_model.weights[slice].tocsr(),
+            **tree_flat_model_params
+        )
+
+        self.subtree_models = []
+        for i in range(len(self.root.children)):
+            subtree_weights_start = self.node_ptr[self.root.children[i].index]
+            subtree_weights_end = self.node_ptr[self.root.children[i+1].index] if i+1 < len(self.root.children) else self.node_ptr[-1]
+            slice = np.s_[:, subtree_weights_start:subtree_weights_end]
+            subtree_flatmodel = linear.FlatModel(
+                name="subtree-flattened-tree",
+                weights=self.flat_model.weights[slice].tocsr(),
+                **tree_flat_model_params
+            )
+            self.subtree_models.append(subtree_flatmodel)
+        
+    def _prune_tree_and_predict_values(self, x: sparse.csr_matrix, beam_width: int) -> np.ndarray:
+        """Calculates the selective decision values associated with instances x by evaluating only the most relevant subtrees.
+
+        Only subtrees corresponding to the top beam_width candidates from the root are evaluated,
+        skipping the rest to avoid unnecessary computation.
+
+        Args:
+            x (sparse.csr_matrix): A matrix with dimension number of instances * number of features.
+            beam_width (int): Number of top candidate branches considered for prediction.
+
+        Returns:
+            np.ndarray: A matrix with dimension number of instances * (number of labels + total number of metalabels).
+        """
+        # Initialize space for all predictions with negative infinity
+        num_instances, num_labels = x.shape[0], self.node_ptr[-1]
+        all_preds = np.full((num_instances, num_labels), -np.inf)
+
+        # Calculate root decision values and scores
+        root_preds = linear.predict_values(self.root_model, x)
+        children_scores = 0.0 - np.square(np.maximum(0, 1 - root_preds))
+
+        slice = np.s_[:, self.node_ptr[self.root.index] : self.node_ptr[self.root.index + 1]]
+        all_preds[slice] = root_preds
+
+        # Select indices of the top beam_width subtrees for each instance
+        top_beam_width_indices = np.argsort(-children_scores, axis=1, kind="stable")[:, :beam_width]
+
+        # Build a mask where mask[i, j] is True if the j-th subtree is among the top beam_width subtrees for the i-th instance
+        mask = np.zeros_like(children_scores, dtype=np.bool_)
+        np.put_along_axis(mask, top_beam_width_indices, True, axis=1)
+        
+        # Calculate predictions for each subtree with its corresponding instances
+        for subtree_idx in range(len(self.root.children)):
+            subtree_model = self.subtree_models[subtree_idx]
+            instances_mask = mask[:, subtree_idx]
+            reduced_instances = x[np.s_[instances_mask], :]
+
+            # Locate the position of the subtree root in the weight mapping of all nodes
+            subtree_weights_start = self.node_ptr[self.root.children[subtree_idx].index]
+            subtree_weights_end = subtree_weights_start + subtree_model.weights.shape[1]
+
+            slice = np.s_[instances_mask, subtree_weights_start:subtree_weights_end]
+            all_preds[slice] = linear.predict_values(subtree_model, reduced_instances)
+
+        return all_preds
+
     def _beam_search(self, instance_preds: np.ndarray, beam_width: int) -> np.ndarray:
         """Predict with beam search using cached probability estimates for a single instance.
 
@@ -93,7 +177,7 @@ class TreeModel:
                 if node.isLeaf():
                     next_level.append((node, score))
                     continue
-                slice = np.s_[self.weight_map[node.index] : self.weight_map[node.index + 1]]
+                slice = np.s_[self.node_ptr[node.index] : self.node_ptr[node.index + 1]]
                 pred = instance_preds[slice]
                 children_score = score - np.square(np.maximum(0, 1 - pred))
                 next_level.extend(zip(node.children, children_score.tolist()))
@@ -102,9 +186,9 @@ class TreeModel:
             next_level = []
 
         num_labels = len(self.root.label_map)
-        scores = np.full(num_labels, 0.0)
+        scores = np.zeros(num_labels)
         for node, score in cur_level:
-            slice = np.s_[self.weight_map[node.index] : self.weight_map[node.index + 1]]
+            slice = np.s_[self.node_ptr[node.index] : self.node_ptr[node.index + 1]]
             pred = instance_preds[slice]
             scores[node.label_map] = np.exp(score - np.square(np.maximum(0, 1 - pred)))
         return scores
@@ -130,7 +214,7 @@ def train_tree(
         verbose (bool, optional): Output extra progress information. Defaults to True.
 
     Returns:
-        A model which can be used in predict_values.
+        TreeModel: A model which can be used in predict_values.
     """
     label_representation = (y.T * x).tocsr()
     label_representation = sklearn.preprocessing.normalize(label_representation, norm="l2", axis=1)
@@ -173,8 +257,8 @@ def train_tree(
     root.dfs(visit)
     pbar.close()
 
-    flat_model, weight_map = _flatten_model(root)
-    return TreeModel(root, flat_model, weight_map)
+    flat_model, node_ptr = _flatten_model(root)
+    return TreeModel(root, flat_model, node_ptr)
 
 
 def _build_tree(label_representation: sparse.csr_matrix, label_map: np.ndarray, d: int, K: int, dmax: int) -> Node:
@@ -188,30 +272,31 @@ def _build_tree(label_representation: sparse.csr_matrix, label_map: np.ndarray,
         dmax (int): Maximum depth of the tree.
 
     Returns:
-        Node: root of the (sub)tree built from label_representation.
+        Node: Root of the (sub)tree built from label_representation.
     """
-    if d >= dmax or label_representation.shape[0] <= K:
-        return Node(label_map=label_map, children=[])
-
-    metalabels = (
-        sklearn.cluster.KMeans(
-            K,
-            random_state=np.random.randint(2**31 - 1),
-            n_init=1,
-            max_iter=300,
-            tol=0.0001,
-            algorithm="elkan",
+    children = []
+    if d < dmax and label_representation.shape[0] > K:
+        if label_representation.shape[0] > 10000:
+            kmeans_algo = ElkanKmeans
+        else:
+            kmeans_algo = LloydKmeans
+
+        kmeans = kmeans_algo(
+            n_clusters=K, max_iter=300, tol=0.0001, random_state=np.random.randint(2**31 - 1), verbose=True
         )
-        .fit(label_representation)
-        .labels_
-    )
+        metalabels = kmeans.fit(label_representation)
 
-    children = []
-    for i in range(K):
-        child_representation = label_representation[metalabels == i]
-        child_map = label_map[metalabels == i]
-        child = _build_tree(child_representation, child_map, d + 1, K, dmax)
-        children.append(child)
+        unique_labels = np.unique(metalabels)
+        if len(unique_labels) == K:
+            create_child_node = lambda i: _build_tree(
+                label_representation[metalabels == i], label_map[metalabels == i], d + 1, K, dmax
+            )
+        else:
+            create_child_node = lambda i: Node(label_map=label_map[metalabels == i], children=[])
+
+        for i in range(K):
+            child = create_child_node(i)
+            children.append(child)
 
     return Node(label_map=label_map, children=children)
 
@@ -261,11 +346,10 @@ def _flatten_model(root: Node) -> tuple[linear.FlatModel, np.ndarray]:
     """Flatten tree weight matrices into a single weight matrix. The flattened weight
     matrix is used to predict all possible values, which is cached for beam search.
     This pessimizes complexity but is faster in practice.
-    Consecutive values of the returned map denotes the start and end indices of the
-    weights of each node. Conceptually, given root and node:
-        flat_model, weight_map = _flatten_model(root)
-        slice = np.s_[weight_map[node.index]:
-                      weight_map[node.index+1]]
+    Consecutive values of the returned array denote the start and end indices of each node in the tree.
+    To extract a node's classifiers:
+        slice = np.s_[node_ptr[node.index]:
+                      node_ptr[node.index+1]]
         node.model.weights == flat_model.weights[:, slice]
 
     Args:
@@ -296,6 +380,6 @@ def _flatten_model(root: Node) -> tuple[linear.FlatModel, np.ndarray]:
     )
 
     # w.shape[1] is the number of labels/metalabels of each node
-    weight_map = np.cumsum([0] + list(map(lambda w: w.shape[1], weights)))
+    node_ptr = np.cumsum([0] + list(map(lambda w: w.shape[1], weights)))
 
-    return model, weight_map
+    return model, node_ptr

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/libmultilabel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: libmultilabel
-Version: 0.7.3
+Version: 0.8.0
 Summary: A library for multi-class and multi-label classification
 Home-page: https://github.com/ASUS-AICS/LibMultiLabel
 Author: LibMultiLabel Team
@@ -16,22 +16,25 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
 License-File: LICENSE
 Requires-Dist: liblinear-multicore>=2.49.0
 Requires-Dist: numba
 Requires-Dist: pandas>1.3.0
 Requires-Dist: PyYAML
 Requires-Dist: scikit-learn
-Requires-Dist: scipy<1.14.0
+Requires-Dist: scipy
 Requires-Dist: tqdm
+Requires-Dist: psutil
+Requires-Dist: sparsekmeans
 Provides-Extra: nn
-Requires-Dist: lightning==2.0.9; extra == "nn"
+Requires-Dist: lightning; extra == "nn"
 Requires-Dist: nltk; extra == "nn"
 Requires-Dist: torch<=2.3; extra == "nn"
 Requires-Dist: torchmetrics==0.10.3; extra == "nn"
 Requires-Dist: torchtext; extra == "nn"
-Requires-Dist: transformers; extra == "nn"
+Requires-Dist: transformers<=4.51.3; extra == "nn"
+Dynamic: license-file
 
 See documentation here: https://www.csie.ntu.edu.tw/~cjlin/libmultilabel

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/libmultilabel.egg-info/requires.txt

@@ -3,13 +3,15 @@ numba
 pandas>1.3.0
 PyYAML
 scikit-learn
-scipy<1.14.0
+scipy
 tqdm
+psutil
+sparsekmeans
 
 [nn]
-lightning==2.0.9
+lightning
 nltk
 torch<=2.3
 torchmetrics==0.10.3
 torchtext
-transformers
+transformers<=4.51.3

{libmultilabel-0.7.3 → libmultilabel-0.8.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = libmultilabel
-version = 0.7.3
+version = 0.8.0
 author = LibMultiLabel Team
 license = MIT License
 license_file = LICENSE
@@ -20,7 +20,7 @@ classifiers =
 	License :: OSI Approved :: MIT License
 	Operating System :: OS Independent
 	Programming Language :: Python :: 3
-	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.10
 
 [options]
 packages = find:
@@ -30,18 +30,20 @@ install_requires =
 	pandas>1.3.0
 	PyYAML
 	scikit-learn
-	scipy<1.14.0
+	scipy
 	tqdm
-python_requires = >=3.8
+	psutil
+	sparsekmeans
+python_requires = >=3.10
 
 [options.extras_require]
 nn = 
-	lightning==2.0.9
+	lightning
 	nltk
 	torch<=2.3
 	torchmetrics==0.10.3
 	torchtext
-	transformers
+	transformers<=4.51.3
 
 [options.packages.find]
 exclude =