libmultilabel 0.7.2__tar.gz → 0.7.4__tar.gz

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libmultilabel
-Version: 0.7.2
+Version: 0.7.4
 Summary: A library for multi-class and multi-label classification
 Home-page: https://github.com/ASUS-AICS/LibMultiLabel
 Author: LibMultiLabel Team
@@ -19,13 +19,14 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 License-File: LICENSE
-Requires-Dist: liblinear-multicore
+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: tqdm
+Requires-Dist: psutil
 Provides-Extra: nn
 Requires-Dist: lightning==2.0.9; extra == "nn"
 Requires-Dist: nltk; extra == "nn"

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/common_utils.py

@@ -34,10 +34,10 @@ class AttributeDict(dict):
         self._used.discard(key)
 
     def used_items(self) -> dict:
-        """Returns the items that have been used at least once after being set.
+        """Return the items that have been used at least once after being set.
 
         Returns:
-            dict: the used items.
+            dict: The used items.
         """
         return {k: self[k] for k in self._used}
 
@@ -46,10 +46,10 @@ def dump_log(log_path, metrics=None, split=None, config=None):
     """Write log including the used items of config and the evaluation scores.
 
     Args:
-        log_path(str): path to log path
-        metrics (dict): metric and scores in dictionary format, defaults to None
-        split (str): val or test, defaults to None
-        config (dict): config to save, defaults to None
+        log_path(str): Path to log path.
+        metrics (dict): Metric and scores in dictionary format, defaults to None.
+        split (str): One of `val` or `test`, defaults to None.
+        config (dict): Config to save, defaults to None.
     """
     os.makedirs(os.path.dirname(log_path), exist_ok=True)
     if os.path.isfile(log_path):
@@ -82,7 +82,8 @@ def argsort_top_k(vals, k, axis=-1):
         k: Consider only the top k elements for each query
         axis: Axis along which to sort. The default is -1 (the last axis).
 
-    Returns: Array of indices that sort vals along the specified axis.
+    Returns: 
+        Array of indices that sort vals along the specified axis.
     """
     unsorted_top_k_idx = np.argpartition(vals, -k, axis=axis)[:, -k:]
     unsorted_top_k_scores = np.take_along_axis(vals, unsorted_top_k_idx, axis=axis)
@@ -130,7 +131,7 @@ def is_multiclass_dataset(dataset, label="label"):
 
 
 def timer(func):
-    """Log info-level wall time"""
+    """Log info-level wall time."""
 
     @wraps(func)
     def wrapper(*args, **kwargs):

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/linear/linear.py

@@ -5,7 +5,7 @@ import os
 
 import numpy as np
 import scipy.sparse as sparse
-from liblinear.liblinearutil import train
+from liblinear.liblinearutil import train, problem, parameter, solver_names
 from tqdm import tqdm
 
 __all__ = [
@@ -39,7 +39,7 @@ class FlatModel:
         self.multiclass = multiclass
 
     def predict_values(self, x: sparse.csr_matrix) -> np.ndarray:
-        """Calculates the decision values associated with x.
+        """Calculate the decision values associated with x.
 
         Args:
             x (sparse.csr_matrix): A matrix with dimension number of instances * number of features.
@@ -79,7 +79,7 @@ def train_1vsrest(
     options: str = "",
     verbose: bool = True,
 ) -> FlatModel:
-    """Trains a linear model for multi-label data using a one-vs-rest strategy.
+    """Train a linear model for multi-label data using a one-vs-rest strategy.
 
     Args:
         y (sparse.csr_matrix): A 0/1 matrix with dimensions number of instances * number of classes.
@@ -169,9 +169,9 @@ def train_thresholding(
     options: str = "",
     verbose: bool = True,
 ) -> FlatModel:
-    """Trains a linear model for multi-label data using a one-vs-rest strategy
+    """Train a linear model for multi-label data using a one-vs-rest strategy
     and cross-validation to pick decision thresholds optimizing the sum of Macro-F1 and Micro-F1.
-    Outperforms train_1vsrest in most aspects at the cost of higher time complexity
+    Outperform train_1vsrest in most aspects at the cost of higher time complexity
     due to an internal cross-validation.
 
     This method is the micromacro-freq approach from this CIKM 2023 paper:
@@ -235,7 +235,7 @@ def _micromacro_one_label(
             negatives, and the number of labels processed.
 
     Returns:
-        tuple[np.ndarray, float, dict]: the weights, threshold, and the updated stats for calculating
+        tuple[np.ndarray, float, dict]: The weights, threshold, and the updated stats for calculating
         Micro-F1.
     """
 
@@ -319,7 +319,7 @@ def _micromacro_one_label(
 
 
 def _do_train(y: np.ndarray, x: sparse.csr_matrix, options: str) -> np.matrix:
-    """Wrapper around liblinear.liblinearutil.train.
+    """Wrap around liblinear.liblinearutil.train.
     Forcibly suppresses all IO regardless of options.
 
     Args:
@@ -328,13 +328,17 @@ def _do_train(y: np.ndarray, x: sparse.csr_matrix, options: str) -> np.matrix:
         options (str): The option string passed to liblinear.
 
     Returns:
-        np.matrix: the weights.
+        np.matrix: The weights.
     """
     if y.shape[0] == 0:
         return np.matrix(np.zeros((x.shape[1], 1)))
 
+    prob = problem(y, x)
+    param = parameter(options)
+    if param.solver_type in [solver_names.L2R_L1LOSS_SVC_DUAL, solver_names.L2R_L2LOSS_SVC_DUAL]:
+        param.w_recalc = True  # only works for solving L1/L2-SVM dual
     with silent_stderr():
-        model = train(y, x, options)
+        model = train(prob, param)
 
     w = np.ctypeslib.as_array(model.w, (x.shape[1], 1))
     w = np.asmatrix(w)
@@ -373,11 +377,11 @@ def _fmeasure(y_true: np.ndarray, y_pred: np.ndarray) -> float:
     """Calculate F1 score.
 
     Args:
-        y_true (np.ndarray): array of +1/-1.
-        y_pred (np.ndarray): array of +1/-1.
+        y_true (np.ndarray): Array of +1/-1.
+        y_pred (np.ndarray): Array of +1/-1.
 
     Returns:
-        float: the F1 score.
+        float: The F1 score.
     """
     tp = np.sum(np.logical_and(y_true == 1, y_pred == 1))
     fn = np.sum(np.logical_and(y_true == 1, y_pred == -1))
@@ -396,10 +400,10 @@ def train_cost_sensitive(
     options: str = "",
     verbose: bool = True,
 ) -> FlatModel:
-    """Trains a linear model for multi-label data using a one-vs-rest strategy
+    """Train a linear model for multi-label data using a one-vs-rest strategy
     and cross-validation to pick an optimal asymmetric misclassification cost
     for Macro-F1.
-    Outperforms train_1vsrest in most aspects at the cost of higher
+    Outperform train_1vsrest in most aspects at the cost of higher
     time complexity.
     See user guide for more details.
 
@@ -413,7 +417,7 @@ def train_cost_sensitive(
     Returns:
         A model which can be used in predict_values.
     """
-    # Follows the MATLAB implementation at https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/multilabel/
+    # Follow the MATLAB implementation at https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/multilabel/
     x, options, bias = _prepare_options(x, options)
 
     y = y.tocsc()
@@ -446,7 +450,7 @@ def _cost_sensitive_one_label(y: np.ndarray, x: sparse.csr_matrix, options: str)
         options (str): The option string passed to liblinear.
 
     Returns:
-        np.ndarray: the weights.
+        np.ndarray: The weights.
     """
 
     l = y.shape[0]
@@ -500,10 +504,10 @@ def train_cost_sensitive_micro(
     options: str = "",
     verbose: bool = True,
 ) -> FlatModel:
-    """Trains a linear model for multi-label data using a one-vs-rest strategy
+    """Train a linear model for multi-label data using a one-vs-rest strategy
     and cross-validation to pick an optimal asymmetric misclassification cost
     for Micro-F1.
-    Outperforms train_1vsrest in most aspects at the cost of higher
+    Outperform train_1vsrest in most aspects at the cost of higher
     time complexity.
     See user guide for more details.
 
@@ -571,7 +575,7 @@ def train_binary_and_multiclass(
     options: str = "",
     verbose: bool = True,
 ) -> FlatModel:
-    """Trains a linear model for binary and multi-class data.
+    """Train a linear model for binary and multi-class data.
 
     Args:
         y (sparse.csr_matrix): A 0/1 matrix with dimensions number of instances * number of classes.
@@ -592,8 +596,12 @@ def train_binary_and_multiclass(
         Invalid dataset. Only multi-class dataset is allowed."""
     y = np.squeeze(nonzero_label_ids)
 
+    prob = problem(y, x)
+    param = parameter(options)
+    if param.solver_type in [solver_names.L2R_L1LOSS_SVC_DUAL, solver_names.L2R_L2LOSS_SVC_DUAL]:
+        param.w_recalc = True
     with silent_stderr():
-        model = train(y, x, options)
+        model = train(prob, param)
 
     # Labels appeared in training set; length may be smaller than num_labels
     train_labels = np.array(model.get_labels(), dtype="int")
@@ -622,7 +630,7 @@ def train_binary_and_multiclass(
 
 
 def predict_values(model, x: sparse.csr_matrix) -> np.ndarray:
-    """Calculates the decision values associated with x, equivalent to model.predict_values(x).
+    """Calculate the decision values associated with x, equivalent to model.predict_values(x).
 
     Args:
         model: A model returned from a training function.

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/linear/metrics.py

@@ -8,7 +8,7 @@ __all__ = ["get_metrics", "compute_metrics", "tabulate_metrics", "MetricCollecti
 
 
 def _argsort_top_k(preds: np.ndarray, top_k: int) -> np.ndarray:
-    """Sorts the top k indices in O(n + k log k) time.
+    """Sort the top k indices in O(n + k log k) time.
     The sorting order is ascending to be consistent with np.sort.
     This means the last element is the largest, the first element is the kth largest.
     """
@@ -18,7 +18,7 @@ def _argsort_top_k(preds: np.ndarray, top_k: int) -> np.ndarray:
 
 
 def _dcg_argsort(argsort_preds: np.ndarray, target: np.ndarray, top_k: int) -> np.ndarray:
-    """Computes DCG@k with a sorted preds array and a target array."""
+    """Compute DCG@k with a sorted preds array and a target array."""
     top_k_idx = argsort_preds[:, -top_k:][:, ::-1]
     gains = np.take_along_axis(target, top_k_idx, axis=-1)
     discount = 1 / (np.log2(np.arange(top_k) + 2))
@@ -28,7 +28,7 @@ def _dcg_argsort(argsort_preds: np.ndarray, target: np.ndarray, top_k: int) -> n
 
 
 def _idcg(target: np.ndarray, top_k: int) -> np.ndarray:
-    """Computes IDCG@k for a 0/1 target array. A 0/1 target is a special case that
+    """Compute IDCG@k for a 0/1 target array. A 0/1 target is a special case that
     doesn't require sorting. If IDCG is computed with DCG,
     then target will need to be sorted, which incurs a large overhead.
     """
@@ -247,7 +247,7 @@ class MetricCollection(dict):
         self.max_k = max(getattr(metric, "top_k", 0) for metric in self.metrics.values())
 
     def update(self, preds: np.ndarray, target: np.ndarray):
-        """Adds a batch of decision values and labels.
+        """Add a batch of decision values and labels.
 
         Args:
             preds (np.ndarray): A matrix of decision values with dimensions number of instances * number of classes.
@@ -268,7 +268,7 @@ class MetricCollection(dict):
                 metric.update(preds, target)
 
     def compute(self) -> dict[str, float]:
-        """Computes the metrics from the accumulated batches of decision values and labels.
+        """Compute the metrics from the accumulated batches of decision values and labels.
 
         Returns:
             dict[str, float]: A dictionary of metric values.
@@ -279,7 +279,7 @@ class MetricCollection(dict):
         return ret
 
     def reset(self):
-        """Clears the accumulated batches of decision values and labels."""
+        """Clear the accumulated batches of decision values and labels."""
         for metric in self.metrics.values():
             metric.reset()
 

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/linear/tree.py

@@ -46,20 +46,21 @@ 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,
         x: sparse.csr_matrix,
         beam_width: int = 10,
     ) -> np.ndarray:
-        """Calculates the probability estimates associated with x.
+        """Calculate the probability estimates associated with x.
 
         Args:
             x (sparse.csr_matrix): A matrix with dimension number of instances * number of features.
@@ -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 -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
@@ -118,7 +202,7 @@ def train_tree(
     dmax=10,
     verbose: bool = True,
 ) -> TreeModel:
-    """Trains a linear model for multi-label data using a divide-and-conquer strategy.
+    """Train a linear model for multi-label data using a divide-and-conquer strategy.
     The algorithm used is based on https://github.com/xmc-aalto/bonsai.
 
     Args:
@@ -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,12 +257,12 @@ 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:
-    """Builds the tree recursively by kmeans clustering.
+    """Build the tree recursively by kmeans clustering.
 
     Args:
         label_representation (sparse.csr_matrix): A matrix with dimensions number of classes under this node * number of features.
@@ -188,7 +272,7 @@ 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=[])
@@ -235,7 +319,7 @@ def get_estimated_model_size(root):
 
 
 def _train_node(y: sparse.csr_matrix, x: sparse.csr_matrix, options: str, node: Node):
-    """If node is internal, computes the metalabels representing each child and trains
+    """If node is internal, compute the metalabels representing each child and train
     on the metalabels. Otherwise, train on y.
 
     Args:
@@ -258,14 +342,13 @@ def _train_node(y: sparse.csr_matrix, x: sparse.csr_matrix, options: str, node:
 
 
 def _flatten_model(root: Node) -> tuple[linear.FlatModel, np.ndarray]:
-    """Flattens tree weight matrices into a single weight matrix. The flattened weight
+    """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:
@@ -289,13 +372,13 @@ def _flatten_model(root: Node) -> tuple[linear.FlatModel, np.ndarray]:
 
     model = linear.FlatModel(
         name="flattened-tree",
-        weights=sparse.hstack(weights, "csr"),
+        weights=sparse.hstack(weights, "csc"),
         bias=bias,
         thresholds=0,
         multiclass=False,
     )
 
     # 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.2 → libmultilabel-0.7.4}/libmultilabel/linear/utils.py

@@ -31,7 +31,7 @@ LINEAR_TECHNIQUES = {
 
 
 def save_pipeline(checkpoint_dir: str, preprocessor: Preprocessor, model):
-    """Saves preprocessor and model to checkpoint_dir/linear_pipline.pickle.
+    """Save preprocessor and model to checkpoint_dir/linear_pipline.pickle.
 
     Args:
         checkpoint_dir (str): The directory to save to.
@@ -53,7 +53,7 @@ def save_pipeline(checkpoint_dir: str, preprocessor: Preprocessor, model):
 
 
 def load_pipeline(checkpoint_path: str) -> tuple[Preprocessor, Any]:
-    """Loads preprocessor and model from checkpoint_path.
+    """Load preprocessor and model from checkpoint_path.
 
     Args:
         checkpoint_path (str): The path to a previously saved pipeline.

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/attentionxml.py

@@ -47,7 +47,7 @@ class PLTTrainer:
             raise ValueError(
                 "The label space of multi-class datasets is usually not large, so PLT training is unnecessary."
                 "Please consider other methods."
-                "If you have a multi-class set with numerous labels, please let us know"
+                "If you have a multi-class set with numerous labels, please let us know."
             )
 
         # cluster
@@ -137,11 +137,11 @@ class PLTTrainer:
         Given the ground-truth labels, [0, 1, 4], the resulting clusters are [0, 2].
 
         Args:
-            cluster_mapping (np.ndarray): mapping from clusters generated by build_label_tree to labels .
-            *labels (csr_matrix): labels in CSR sparse format.
+            cluster_mapping (np.ndarray): Mapping from clusters generated by build_label_tree to labels.
+            *labels (csr_matrix): Labels in CSR sparse format.
 
         Returns:
-            Generator[csr_matrix]: resulting clusters converted from labels in CSR sparse format
+            Generator[csr_matrix]: Resulting clusters converted from labels in CSR sparse format.
         """
         mapping = np.empty(self.num_classes, dtype=np.uint32)
         for idx, clusters in enumerate(cluster_mapping):
@@ -169,12 +169,12 @@ class PLTTrainer:
         Also notice that this function deals with DENSE matrix.
 
         Args:
-            cluster_mapping (np.ndarray): mapping from clusters generated by build_label_tree to labels .
-            clusters (np.ndarray): predicted clusters from model 0.
-            cluster_scores (Optional: np.ndarray): predicted scores of each cluster from model 0.
+            cluster_mapping (np.ndarray): Mapping from clusters generated by build_label_tree to labels.
+            clusters (np.ndarray): Predicted clusters from model 0.
+            cluster_scores (Optional: np.ndarray): Predicted scores of each cluster from model 0.
 
         Returns:
-            Generator[np.ndarray]: resulting labels expanded from clusters
+            Generator[np.ndarray]: Resulting labels expanded from clusters.
         """
 
         labels_selected = []
@@ -192,10 +192,10 @@ class PLTTrainer:
             return labels_selected
 
     def fit(self, datasets):
-        """fit model to the training dataset
+        """Fit model to the training dataset.
 
         Args:
-            datasets: dict containing training, validation, and/or test datasets
+            datasets: Dict containing training, validation, and/or test datasets.
         """
         if self.get_best_model_path(level=1).exists():
             return
@@ -596,8 +596,8 @@ class PlainDataset(Dataset):
     this while generating clusters. There is no need to do multilabel binarization again.
 
     Args:
-        x (list | ndarray | Tensor): texts.
-        y (Optional: csr_matrix | ndarray | Tensor): labels.
+        x (list | ndarray | Tensor): Texts.
+        y (Optional: csr_matrix | ndarray | Tensor): Labels.
     """
 
     def __init__(self, x, y=None):
@@ -633,12 +633,12 @@ class PLTDataset(PlainDataset):
     """Dataset for model_1 of AttentionXML.
 
     Args:
-        x: texts.
-        y: labels.
+        x: Texts.
+        y: Labels.
         num_classes: number of classes.
-        num_labels_selected: the number of selected labels.
-        labels_selected: sampled predicted labels from model_0. Shape: (len(x), predict_top_k).
-        label_scores: scores for each label. Shape: (len(x), predict_top_k).
+        num_labels_selected: The number of selected labels.
+        labels_selected: Sampled predicted labels from model_0. Shape: (len(x), predict_top_k).
+        label_scores: Scores for each label. Shape: (len(x), predict_top_k).
     """
 
     def __init__(
@@ -709,10 +709,10 @@ def build_label_tree(sparse_x: csr_matrix, sparse_y: csr_matrix, cluster_size: i
     ((0, 2), (1, 3), (4, 5)).
 
     Args:
-        sparse_x: features extracted from texts in CSR sparse format
-        sparse_y: binarized labels in CSR sparse format
-        cluster_size: the maximum number of labels within each cluster
-        output_dir: directory to store the clustering file
+        sparse_x: Features extracted from texts in CSR sparse format.
+        sparse_y: Binarized labels in CSR sparse format.
+        cluster_size: The maximum number of labels within each cluster.
+        output_dir: Directory to store the clustering file.
     """
     # skip constructing label tree if the output file already exists
     output_dir = output_dir if isinstance(output_dir, Path) else Path(output_dir)
@@ -755,8 +755,8 @@ def _split_cluster(cluster: ndarray, label_repr: csr_matrix) -> tuple[ndarray, n
     2. the end-of-loop criterion is the difference between the new and old average in-cluster distances to centroids.
 
     Args:
-        cluster: a subset of labels
-        label_repr: the normalized representations of the relationship between labels and texts of the given cluster
+        cluster: A subset of labels.
+        label_repr: The normalized representations of the relationship between labels and texts of the given cluster.
     """
     # Randomly choose two points as initial centroids and obtain their label representations
     centroids = label_repr[np.random.choice(len(cluster), size=2, replace=False)].toarray()

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/data_utils.py

@@ -355,7 +355,7 @@ def get_embedding_weights_from_file(word_dict, embed_file, silent=False, cache=N
         cache (str, optional): Path to a directory for storing cached embeddings. Defaults to None.
 
     Returns:
-        torch.Tensor: Embedding weights (vocab_size, embed_size)
+        torch.Tensor: Embedding weights (vocab_size, embed_size).
     """
     # Load pretrained word embedding
     load_embedding_from_file = embed_file not in pretrained_aliases

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/metrics.py

@@ -13,7 +13,7 @@ class _PrecisonRecallWrapperMetric(Metric):
     """Encapsulate common functions of RPrecision, PrecisionAtK, and RecallAtK.
 
     Args:
-        top_k (int): the top k relevant labels to evaluate.
+        top_k (int): The top k relevant labels to evaluate.
     """
 
     # If the metric state of one batch is independent of the state of other batches,
@@ -133,7 +133,7 @@ class NDCGAtK(Metric):
     As a result, we implement our own batch-wise NDCG.
 
     Args:
-        top_k (int): the top k relevant labels to evaluate.
+        top_k (int): The top k relevant labels to evaluate.
     """
 
     # If the metric state of one batch is independent of the state of other batches,
@@ -170,7 +170,7 @@ class NDCGAtK(Metric):
         return (gains * discount).sum(dim=1)
 
     def _idcg(self, target, discount):
-        """Computes IDCG@k for a 0/1 target tensor.
+        """Compute IDCG@k for a 0/1 target tensor.
         A 0/1 target is a special case that doesn't require sorting.
         """
         cum_discount = discount.cumsum(dim=0)

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/model.py

@@ -11,7 +11,7 @@ from ..nn.metrics import get_metrics, tabulate_metrics
 
 
 class MultiLabelModel(L.LightningModule):
-    """Abstract class handling Pytorch Lightning training flow
+    """Abstract class handling Pytorch Lightning training flow.
 
     Args:
         num_classes (int): Total number of classes.
@@ -70,7 +70,7 @@ class MultiLabelModel(L.LightningModule):
 
     @abstractmethod
     def shared_step(self, batch):
-        """Return loss and predicted logits"""
+        """Return loss and predicted logits."""
         return NotImplemented
 
     def configure_optimizers(self):
@@ -164,11 +164,11 @@ class MultiLabelModel(L.LightningModule):
         return {"top_k_pred": top_k_idx, "top_k_pred_scores": top_k_scores}
 
     def forward(self, batch):
-        """compute predicted logits"""
+        """Compute predicted logits."""
         return self.network(batch)["logits"]
 
     def print(self, *args, **kwargs):
-        """Prints only from process 0 and not in silent mode. Use this in any
+        """Print only from process 0 and not in silent mode. Use this in any
         distributed mode to log only once."""
 
         if not self.silent:

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/bert.py

@@ -3,7 +3,7 @@ from transformers import AutoModelForSequenceClassification
 
 
 class BERT(nn.Module):
-    """BERT
+    """BERT.
 
     Args:
         num_classes (int): Total number of classes.

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/bert_attention.py

@@ -6,7 +6,7 @@ from .modules import LabelwiseAttention, LabelwiseLinearOutput, LabelwiseMultiHe
 
 
 class BERTAttention(nn.Module):
-    """BERT + Label-wise Document Attention or Multi-Head Attention
+    """BERT + Label-wise Document Attention or Multi-Head Attention.
 
     Args:
         num_classes (int): Total number of classes.

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/caml.py

@@ -7,8 +7,8 @@ from torch.nn.init import xavier_uniform_
 
 class CAML(nn.Module):
     """CAML (Convolutional Attention for Multi-Label classification)
-    Follows the work of Mullenbach et al. [https://aclanthology.org/N18-1100.pdf]
-    This class is for reproducing the results in the paper.
+    Following Mullenbach et al. [https://aclanthology.org/N18-1100.pdf],
+    this class is for reproducing the results in the paper.
     Use CNNLWAN instead for better modularization.
 
     Args:

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/kim_cnn.py

@@ -5,7 +5,7 @@ from .modules import Embedding, CNNEncoder
 
 
 class KimCNN(nn.Module):
-    """KimCNN
+    """KimCNN.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/labelwise_attention_networks.py

@@ -16,7 +16,7 @@ from .modules import (
 
 
 class LabelwiseAttentionNetwork(ABC, nn.Module):
-    """Base class for Labelwise Attention Network
+    """Base class for Labelwise Attention Network.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).
@@ -48,7 +48,7 @@ class LabelwiseAttentionNetwork(ABC, nn.Module):
 
 
 class RNNLWAN(LabelwiseAttentionNetwork):
-    """Base class for RNN Labelwise Attention Network"""
+    """Base class for RNN Labelwise Attention Network."""
 
     def forward(self, input):
         # (batch_size, sequence_length, embed_dim)
@@ -61,7 +61,7 @@ class RNNLWAN(LabelwiseAttentionNetwork):
 
 
 class BiGRULWAN(RNNLWAN):
-    """BiGRU Labelwise Attention Network
+    """BiGRU Labelwise Attention Network.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).
@@ -111,7 +111,7 @@ class BiGRULWAN(RNNLWAN):
 
 
 class BiLSTMLWAN(RNNLWAN):
-    """BiLSTM Labelwise Attention Network
+    """BiLSTM Labelwise Attention Network.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).
@@ -155,7 +155,7 @@ class BiLSTMLWAN(RNNLWAN):
 
 
 class BiLSTMLWMHAN(LabelwiseAttentionNetwork):
-    """BiLSTM Labelwise Multihead Attention Network
+    """BiLSTM Labelwise Multihead Attention Network.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).
@@ -217,7 +217,7 @@ class BiLSTMLWMHAN(LabelwiseAttentionNetwork):
 
 
 class CNNLWAN(LabelwiseAttentionNetwork):
-    """CNN Labelwise Attention Network
+    """CNN Labelwise Attention Network.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/modules.py

@@ -7,7 +7,7 @@ from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
 
 
 class Embedding(nn.Module):
-    """Embedding layer with dropout
+    """Embedding layer with dropout.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).
@@ -26,7 +26,7 @@ class Embedding(nn.Module):
 
 
 class RNNEncoder(ABC, nn.Module):
-    """Base class of RNN encoder with dropout
+    """Base class of RNN encoder with dropout.
 
     Args:
         input_size (int): The number of expected features in the input.
@@ -55,7 +55,7 @@ class RNNEncoder(ABC, nn.Module):
 
 
 class GRUEncoder(RNNEncoder):
-    """Bi-directional GRU encoder with dropout
+    """Bi-directional GRU encoder with dropout.
 
     Args:
         input_size (int): The number of expected features in the input.
@@ -73,7 +73,7 @@ class GRUEncoder(RNNEncoder):
 
 
 class LSTMEncoder(RNNEncoder):
-    """Bi-directional LSTM encoder with dropout
+    """Bi-directional LSTM encoder with dropout.
 
     Args:
         input_size (int): The number of expected features in the input.
@@ -91,7 +91,7 @@ class LSTMEncoder(RNNEncoder):
 
 
 class CNNEncoder(nn.Module):
-    """Multi-filter-size CNN encoder for text classification with max-pooling
+    """Multi-filter-size CNN encoder for text classification with max-pooling.
 
     Args:
         input_size (int): The number of expected features in the input.
@@ -103,7 +103,7 @@ class CNNEncoder(nn.Module):
                         If num_pool = 0, do nothing.
                         If num_pool = 1, do typical max-pooling.
                         If num_pool > 1, do adaptive max-pooling.
-        channel_last (bool): Whether to transpose the dimension from (batch_size, num_channel, length) to (batch_size, length, num_channel)
+        channel_last (bool): Whether to transpose the dimension from (batch_size, num_channel, length) to (batch_size, length, num_channel).
     """
 
     def __init__(
@@ -149,8 +149,8 @@ class CNNEncoder(nn.Module):
 
 
 class LabelwiseAttention(nn.Module):
-    """Applies attention technique to summarize the sequence for each label
-    See `Explainable Prediction of Medical Codes from Clinical Text <https://aclanthology.org/N18-1100.pdf>`_
+    """Apply attention technique to summarize the sequence for each label.
+    See `Explainable Prediction of Medical Codes from Clinical Text <https://aclanthology.org/N18-1100.pdf>`_.
 
     Args:
         input_size (int): The number of expected features in the input.
@@ -171,7 +171,7 @@ class LabelwiseAttention(nn.Module):
 
 
 class LabelwiseMultiHeadAttention(nn.Module):
-    """Labelwise multi-head attention
+    """Labelwise multi-head attention.
 
     Args:
         input_size (int): The number of expected features in the input.
@@ -197,7 +197,7 @@ class LabelwiseMultiHeadAttention(nn.Module):
 
 
 class LabelwiseLinearOutput(nn.Module):
-    """Applies a linear transformation to the incoming data for each label
+    """Apply a linear transformation to the incoming data for each label.
 
     Args:
         input_size (int): The number of expected features in the input.

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel/nn/networks/xml_cnn.py

@@ -6,7 +6,7 @@ from .modules import Embedding, CNNEncoder
 
 
 class XMLCNN(nn.Module):
-    """XML-CNN
+    """XML-CNN.
 
     Args:
         embed_vecs (torch.Tensor): The pre-trained word vectors of shape (vocab_size, embed_dim).

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libmultilabel
-Version: 0.7.2
+Version: 0.7.4
 Summary: A library for multi-class and multi-label classification
 Home-page: https://github.com/ASUS-AICS/LibMultiLabel
 Author: LibMultiLabel Team
@@ -19,13 +19,14 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 License-File: LICENSE
-Requires-Dist: liblinear-multicore
+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: tqdm
+Requires-Dist: psutil
 Provides-Extra: nn
 Requires-Dist: lightning==2.0.9; extra == "nn"
 Requires-Dist: nltk; extra == "nn"

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/libmultilabel.egg-info/requires.txt

@@ -1,10 +1,11 @@
-liblinear-multicore
+liblinear-multicore>=2.49.0
 numba
 pandas>1.3.0
 PyYAML
 scikit-learn
 scipy<1.14.0
 tqdm
+psutil
 
 [nn]
 lightning==2.0.9

{libmultilabel-0.7.2 → libmultilabel-0.7.4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = libmultilabel
-version = 0.7.2
+version = 0.7.4
 author = LibMultiLabel Team
 license = MIT License
 license_file = LICENSE
@@ -25,13 +25,14 @@ classifiers =
 [options]
 packages = find:
 install_requires = 
-	liblinear-multicore
+	liblinear-multicore>=2.49.0
 	numba
 	pandas>1.3.0
 	PyYAML
 	scikit-learn
 	scipy<1.14.0
 	tqdm
+	psutil
 python_requires = >=3.8
 
 [options.extras_require]