mlquantify 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

mlquantify/__init__.py

@@ -11,4 +11,7 @@ from . import base
 from . import calibration
 from . import confidence
 from . import multiclass
-from . import neural
+try:
+    from . import neural
+except NameError:
+    pass

mlquantify/adjust_counting/_adjustment.py

@@ -208,24 +208,23 @@ class MatrixAdjustment(BaseAdjustCount):
         pp. 1-8.
     """
 
-
     _parameter_constraints = {"solver": Options(["optim", "linear"])}
 
     def __init__(self, learner=None, solver=None):
         super().__init__(learner=learner)
         self.solver = solver
     
-    def _adjust(self, predictions, train_y_pred, y_train):
+    def _adjust(self, predictions, train_predictions, y_train):
         n_class = len(np.unique(y_train))
         self.CM = np.zeros((n_class, n_class))
-
         if self.solver == 'optim':
-            priors = np.array(list(CC().aggregate(train_y_pred, y_train).values()))
-            self.CM = self._compute_confusion_matrix(train_y_pred, y_train, priors)
+            class_counts = np.array([np.count_nonzero(y_train == _class) for _class in self.classes_])
+            priors = class_counts / len(y_train)
+            self.CM = self._compute_confusion_matrix(train_predictions, y_train, priors)
             prevs_estim = self._get_estimations(predictions > priors, y_train)
             prevalence = self._solve_optimization(prevs_estim, priors)
         else:
-            self.CM = self._compute_confusion_matrix(train_y_pred, y_train)
+            self.CM = self._compute_confusion_matrix(train_predictions, y_train)
             prevs_estim = self._get_estimations(predictions, y_train)
             prevalence = self._solve_linear(prevs_estim)
         
@@ -244,26 +243,31 @@ class MatrixAdjustment(BaseAdjustCount):
         return adjusted
 
     def _solve_optimization(self, prevs_estim, priors):
-        r"""Solve the system linearly.
+        r"""Solve the system using constrained optimization.
 
-        The solution is obtained by matrix inversion:
+        The solution is obtained by minimizing the discrepancy:
 
-        .. math::
+            || C @ \hat{\pi}_F - p ||
 
-            \hat{\pi}_F = \mathbf{C}^{-1} \mathbf{p}
+        subject to the constraints:
 
-        where :math:`\mathbf{C}` is the confusion matrix and :math:`\mathbf{p}` 
-        is the observed prevalence vector.
+            \hat{\pi}_F \ge 0,  sum_k \hat{\pi}_{F,k} = 1
+
+        where:
+            - C is the confusion matrix,
+            - p is the observed prevalence vector from the test set.
 
         Parameters
         ----------
-        p : ndarray of shape (n_classes,)
-            Observed prevalence vector from test set.
+        prevs_estim : ndarray of shape (n_classes,)
+            Observed prevalence vector from the test set.
+        priors : ndarray of shape (n_classes,)
+            Fallback class prior vector used if optimization fails.
 
         Returns
         -------
         ndarray of shape (n_classes,)
-            Adjusted prevalence estimates :math:`\hat{\pi}_F`.
+            Adjusted prevalence estimates \hat{\pi}_F.
         """
         def objective(prevs_pred):
             return np.linalg.norm(self.CM @ prevs_pred - prevs_estim)
@@ -294,19 +298,27 @@ class CDE(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
     r"""CDE-Iterate for binary classification prevalence estimation.
 
     Threshold :math:`\tau` from false positive and false negative costs:
+
     .. math::
+
         \tau = \frac{c_{FP}}{c_{FP} + c_{FN}}
 
     Hard classification by thresholding posterior probability :math:`p(+|x)` at :math:`\tau`:
+
     .. math::
+
         \hat{y}(x) = \mathbf{1}_{p(+|x) > \tau}
 
     Prevalence estimation via classify-and-count:
+
     .. math::
+
         \hat{p}_U(+) = \frac{1}{N} \sum_{n=1}^N \hat{y}(x_n)
 
     False positive cost update:
+    
     .. math::
+
         c_{FP}^{new} = \frac{p_L(+)}{p_L(-)} \times \frac{\hat{p}_U(-)}{\hat{p}_U(+)} \times c_{FN}
 
     Parameters
@@ -365,6 +377,31 @@ class CDE(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
 
 
     def aggregate(self, predictions, y_train):
+        """Aggregate predictions and apply matrix- or rate-based bias correction. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import CDE
+        >>> import numpy as np
+        >>> q = CDE()
+        >>> predictions = np.random.rand(200)
+        >>> train_predictions = np.random.rand(200) # generated via cross-validation
+        >>> y_train = np.random.randint(0, 2, 200)
+        >>> q.aggregate(predictions, train_predictions, y_train)
+        {0: 0.51, 1: 0.49}
+        """
 
         self.classes_ = check_classes_attribute(self, np.unique(y_train))
         predictions = validate_predictions(self, predictions)
@@ -465,7 +502,7 @@ class FM(SoftLearnerQMixin, MatrixAdjustment):
         \min_{\hat{\pi}_F} \| \mathbf{C} \hat{\pi}_F - \mathbf{p} \|^2
 
     subject to constraints:
-
+    
     .. math::
 
         \hat{\pi}_F \geq 0, \quad \sum_k \hat{\pi}_{F,k} = 1
@@ -478,7 +515,7 @@ class FM(SoftLearnerQMixin, MatrixAdjustment):
     ----------
     learner : estimator, optional
         Base classifier with `fit` and `predict_proba` methods.
-        If None, a default estimator will be used.
+        If None, it is expected that user will use the `aggregate` method directly.
 
     Attributes
     ----------
@@ -505,13 +542,28 @@ class FM(SoftLearnerQMixin, MatrixAdjustment):
     def __init__(self, learner=None):
         super().__init__(learner=learner, solver='optim')
     
-    def _compute_confusion_matrix(self, posteriors, y_true, priors):
+    def _compute_confusion_matrix(self, predictions, y_true, priors):
+        n_classes = len(self.classes_)
+        self.CM = np.zeros((n_classes, n_classes))
+
         for i, _class in enumerate(self.classes_):
             indices = (y_true == _class)
-            self.CM[:, i] = self._get_estimations(posteriors[indices] > priors, y_true[indices])
+            preds_sub = predictions[indices]
+
+            mask = preds_sub > priors               # (n_i, n_classes)
+            masked = np.where(mask, preds_sub, -np.inf)
+            best_classes = np.argmax(masked, axis=1)
+
+            hard_preds = np.zeros_like(preds_sub, dtype=bool)
+            rows = np.arange(preds_sub.shape[0])
+            hard_preds[rows, best_classes] = True
+
+            self.CM[:, i] = self._get_estimations(hard_preds, y_true[indices])
+        
         return self.CM
 
 
+
 class AC(CrispLearnerQMixin, MatrixAdjustment):
     r"""Adjusted Count method.
 

mlquantify/adjust_counting/_base.py

@@ -114,7 +114,6 @@ class BaseCount(AggregationMixin, BaseQuantifier):
     
     @abstractmethod
     def aggregate(self, predictions):
-        """Aggregate predictions into class prevalence estimates."""
         ...
 
 
@@ -156,7 +155,7 @@ class BaseAdjustCount(AggregationMixin, BaseQuantifier):
     Parameters
     ----------
     learner : object, optional
-        Supervised learner implementing `fit`, `predict`, or `predict_proba`.
+        Supervised learner implementing `fit` and (`predict` or `predict_proba`) depending on the quantifier.
 
     Attributes
     ----------
@@ -164,7 +163,7 @@ class BaseAdjustCount(AggregationMixin, BaseQuantifier):
         Underlying classification model.
     train_predictions : ndarray of shape (n_samples_train, n_classes)
         Predictions on training data from cross-validation.
-    train_y_values : ndarray of shape (n_samples_train,)
+    y_train : ndarray of shape (n_samples_train,)
         True labels corresponding to training predictions.
     classes : ndarray of shape (n_classes,)
         Unique class labels.
@@ -225,17 +224,44 @@ class BaseAdjustCount(AggregationMixin, BaseQuantifier):
             )
         
         self.train_predictions = train_predictions
-        self.train_y_values = y_train_labels
+        self.y_train = y_train_labels
         return self
     
     def predict(self, X):
         """Predict class prevalences for the given data."""
+        X = validate_data(self, X)
         predictions = getattr(self.learner, _get_learner_function(self))(X)
-        prevalences = self.aggregate(predictions, self.train_predictions, self.train_y_values)
+        prevalences = self.aggregate(predictions, self.train_predictions, self.y_train)
         return prevalences
 
     def aggregate(self, predictions, train_predictions, y_train):
-        """Aggregate predictions and apply matrix- or rate-based bias correction."""
+        """Aggregate predictions and apply matrix- or rate-based bias correction. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        train_predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on training data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import AC
+        >>> import numpy as np
+        >>> q = AC()
+        >>> predictions = np.random.rand(200)
+        >>> train_predictions = np.random.rand(200) # generated via cross-validation
+        >>> y_train = np.random.randint(0, 2, 200)
+        >>> q.aggregate(predictions, train_predictions, y_train)
+        {0: 0.51, 1: 0.49}
+        """
         self.classes_ = check_classes_attribute(self, np.unique(y_train))
         
         predictions = validate_predictions(self, predictions)

mlquantify/adjust_counting/_counting.py

@@ -15,7 +15,7 @@ class CC(CrispLearnerQMixin, BaseCount):
     r"""Classify and Count (CC) quantifier.
 
     Implements the Classify and Count method for quantification, describe as a
-    baseline approach in the literature [1][2].
+    baseline approach in the literature [1]_, [2]_.
 
     Parameters
     ----------
@@ -51,17 +51,15 @@ class CC(CrispLearnerQMixin, BaseCount):
     >>> q.fit(X, y)
     >>> q.predict(X)
     {0: 0.47, 1: 0.53}
-    >>> q2 = CC()
-    >>> predictions = np.random.rand(200)
-    >>> q2.aggregate(predictions)
-    {0: 0.51, 1: 0.49}
 
     References
     ----------
-    .. [1] Forman, G. (2005). "Counting Positives Accurately Despite Inaccurate Classification",
-           *ECML*, pp. 564-575.
-    .. [2] Forman, G. (2008). "Quantifying Counts and Costs via Classification",
-           *Data Mining and Knowledge Discovery*, 17(2), 164-206.
+    .. dropdown:: References
+
+        .. [1] Forman, G. (2005). "Counting Positives Accurately Despite Inaccurate Classification",
+            *ECML*, pp. 564-575.
+        .. [2] Forman, G. (2008). "Quantifying Counts and Costs via Classification",
+            *Data Mining and Knowledge Discovery*, 17(2), 164-206.
     """
     
     _parameters_constraints = {
@@ -76,6 +74,29 @@ class CC(CrispLearnerQMixin, BaseCount):
         self.threshold = threshold
 
     def aggregate(self, predictions, y_train=None):
+        """Aggregate predictions into class prevalence estimates. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data. None by default.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import CC
+        >>> import numpy as np
+        >>> q = CC()
+        >>> predictions = np.random.rand(200)
+        >>> q.aggregate(predictions)
+        {0: 0.51, 1: 0.49}
+        """
         predictions = validate_predictions(self, predictions, self.threshold, y_train)
         
         if y_train is None:
@@ -92,12 +113,8 @@ class CC(CrispLearnerQMixin, BaseCount):
 class PCC(SoftLearnerQMixin, BaseCount):
     r"""Probabilistic Classify and Count (PCC) quantifier.
     
-    Implements the Probabilistic Classify and Count method for quantification as described in:
-    [1] Forman, G. (2005). *Counting Positives Accurately Despite Inaccurate Classification.*
-        ECML, pp. 564-575.
-    [2] Forman, G. (2008). *Quantifying Counts and Costs via Classification.*
-        Data Mining and Knowledge Discovery, 17(2), 164-206.
-        
+    Implements the Probabilistic Classify and Count method for quantification as described in [1]_, [2]_:
+    
         
     Parameters
     ----------
@@ -112,6 +129,11 @@ class PCC(SoftLearnerQMixin, BaseCount):
         Underlying classification model.
     classes : ndarray of shape (n_classes,)
         Unique class labels observed during training.
+
+    .. dropdown:: References
+    
+        .. [1] Forman, G. (2005). *Counting Positives Accurately Despite Inaccurate Classification.* ECML, pp. 564-575.
+        .. [2] Forman, G. (2008). *Quantifying Counts and Costs via Classification.* Data Mining and Knowledge Discovery, 17(2), 164-206.
         
         
     Examples
@@ -125,16 +147,35 @@ class PCC(SoftLearnerQMixin, BaseCount):
     >>> q.fit(X, y)
     >>> q.predict(X)
     {0: 0.48, 1: 0.52}
-    >>> q2 = PCC()
-    >>> predictions = np.random.rand(200, 2)
-    >>> q2.aggregate(predictions)
-    {0: 0.50, 1: 0.50}
     """
 
     def __init__(self, learner=None):
         super().__init__(learner=learner)
 
     def aggregate(self, predictions, y_train=None):
+        """Aggregate predictions into class prevalence estimates. 
+        
+        Parameters
+        ----------
+        predictions : ndarray of shape (n_samples, n_classes)
+            Learner predictions on test data. Can be probabilities (n_samples, n_classes) or class labels (n_samples,).
+        y_train : ndarray of shape (n_samples,)
+            True class labels of the training data. None by default.
+        
+        Returns
+        -------
+        ndarray of shape (n_classes,)
+            Class prevalence estimates.
+
+        Examples
+        --------
+        >>> from mlquantify.adjust_counting import PCC
+        >>> import numpy as np
+        >>> q = PCC()
+        >>> predictions = np.random.rand(200, 2)
+        >>> q.aggregate(predictions)
+        {0: 0.50, 1: 0.50}
+        """
         predictions = validate_predictions(self, predictions)
         
         # Handle categorical predictions (1D array with class labels)

mlquantify/confidence.py

@@ -96,14 +96,15 @@ class ConfidenceInterval(BaseConfidenceRegion):
     The confidence region is defined as:
 
     .. math::
-        CI_α(π) = 
-        \\begin{cases}
-        1 & \\text{if } L_i \\le π_i \\le U_i, \\forall i=1,...,n \\\\
-        0 & \\text{otherwise}
-        \\end{cases}
 
-    where :math:`L_i` and :math:`U_i` are the empirical 
-    α/2 and 1−α/2 quantiles for class i.
+        CI_{\alpha}(\pi) =
+        \begin{cases}
+        1 & \text{if } L_i \le \pi_i \le U_i, \forall i=1,\dots,n \\
+        0 & \text{otherwise}
+        \end{cases}
+
+    where :math:`L_i` and :math:`U_i` are the empirical
+    :math:`\alpha/2` and :math:`1-\alpha/2` quantiles for class :math:`i`.
 
     Parameters
     ----------
@@ -163,9 +164,10 @@ class ConfidenceEllipseSimplex(BaseConfidenceRegion):
     Defines a multivariate confidence region based on a chi-squared threshold:
 
     .. math::
-        CE_α(π) =
+
+        CE_{\alpha}(\pi) =
         \\begin{cases}
-        1 & \\text{if } (π - μ)^T Σ^{-1} (π - μ) \\le χ^2_{n-1}(1-α) \\\\
+        1 & \\text{if } (\pi - \mu)^T \Sigma^{-1} (\pi - \mu) \\le \chi^2_{n-1}(1-\alpha) \\\\
         0 & \\text{otherwise}
         \\end{cases}
 
@@ -237,17 +239,19 @@ class ConfidenceEllipseCLR(ConfidenceEllipseSimplex):
     Applies the Centered Log-Ratio (CLR) transformation:
 
     .. math::
-        T(π) = [\log(π_1/g(π)), ..., \log(π_n/g(π))], \\
-        g(π) = (\prod_i π_i)^{1/n}
+
+        T(\pi) = [\log(\pi_1/g(\pi)), ..., \log(\pi_n/g(\pi))], \\
+        g(\pi) = (\prod_i \pi_i)^{1/n}
 
     A confidence ellipse is then built in the transformed space:
 
     .. math::
-        CT_α(π) =
-        \\begin{cases}
-        1 & \\text{if } (T(π) - μ_{CLR})^T Σ^{-1} (T(π) - μ_{CLR}) \\le χ^2_{n-1}(1-α) \\\\
-        0 & \\text{otherwise}
-        \\end{cases}
+    
+        CT_\alpha(\pi) =
+        \begin{cases}
+        1 & \text{if } (T(\pi) - \mu_{CLR})^T \Sigma^{-1} (T(\pi) - \mu_{CLR}) \le \chi^2_{n-1}(1-\alpha) \\
+        0 & \text{otherwise}
+        \end{cases}
 
     Parameters
     ----------

mlquantify/likelihood/_classes.py

@@ -16,36 +16,53 @@ class EMQ(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
     Estimates class prevalences under prior probability shift by alternating 
     between expectation **(E)** and maximization **(M)** steps on posterior probabilities. 
 
-    E-step:
-    .. math::
-        p_i^{(s+1)}(x) = \frac{q_i^{(s)} p_i(x)}{\sum_j q_j^{(s)} p_j(x)}
+    .. dropdown:: Mathematical Formulation
 
-    M-step:
-    .. math::
-        q_i^{(s+1)} = \frac{1}{N} \sum_{n=1}^N p_i^{(s+1)}(x_n)
+        E-step:
 
-    where 
-    - :math:`p_i(x)` are posterior probabilities predicted by the classifier
-    - :math:`q_i^{(s)}` are class prevalence estimates at iteration :math:`s`
-    - :math:`N` is the number of test instances.
+        .. math::
 
-    Calibrations supported on posterior probabilities before **EM** iteration:
+            p_i^{(s+1)}(x) = \frac{q_i^{(s)} p_i(x)}{\sum_j q_j^{(s)} p_j(x)}
 
-    Temperature Scaling (TS):
-    .. math::
-        \hat{p} = \text{softmax}\left(\frac{\log(p)}{T}\right)
+        M-step:
 
-    Bias-Corrected Temperature Scaling (BCTS):
-    .. math::
-        \hat{p} = \text{softmax}\left(\frac{\log(p)}{T} + b\right)
+        .. math::
 
-    Vector Scaling (VS):
-    .. math::
-        \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i) + b_i)
+            q_i^{(s+1)} = \frac{1}{N} \sum_{n=1}^N p_i^{(s+1)}(x_n)
 
-    No-Bias Vector Scaling (NBVS):
-    .. math::
-        \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i))
+        where:
+
+        - :math:`p_i(x)` are posterior probabilities predicted by the classifier
+
+        - :math:`q_i^{(s)}` are class prevalence estimates at iteration :math:`s`
+
+        - :math:`N` is the number of test instances.
+
+        Calibrations supported on posterior probabilities before **EM** iteration:
+
+        Temperature Scaling (TS):
+
+        .. math::
+
+            \hat{p} = \text{softmax}\left(\frac{\log(p)}{T}\right)
+
+        Bias-Corrected Temperature Scaling (BCTS):
+
+        .. math::
+
+            \hat{p} = \text{softmax}\left(\frac{\log(p)}{T} + b\right)
+
+        Vector Scaling (VS):
+
+        .. math::
+
+            \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i) + b_i)
+
+        No-Bias Vector Scaling (NBVS):
+
+        .. math::
+
+            \hat{p}_i = \text{softmax}(W_i \cdot \log(p_i))
 
     Parameters
     ----------

mlquantify/neural/_classes.py

@@ -4,14 +4,14 @@ from typing import Dict, Any, Sequence
 
 import numpy as np
 from sklearn.model_selection import train_test_split
+
 try:
     import torch
     import torch.nn as nn
     from torch.nn import MSELoss
     from torch.nn.functional import relu
 except ImportError:
-    import warnings
-    warnings.warn("torch is not installed. Neural network quantifiers will not work.")
+    pass
 
 from mlquantify.base import BaseQuantifier
 from mlquantify.base_aggregative import (

mlquantify/utils/_validation.py

@@ -94,12 +94,12 @@ def validate_y(quantifier: Any, y: np.ndarray) -> None:
             f"Predictions must be 1D or 2D array, got array with ndim={y.ndim} and shape={y.shape}."
         )
 
-def _get_valid_crisp_predictions(predictions, train_y_values=None, threshold=0.5):
+def _get_valid_crisp_predictions(predictions, y_train=None, threshold=0.5):
     predictions = np.asarray(predictions)
     dimensions = predictions.ndim
 
-    if train_y_values is not None:
-        classes = np.unique(train_y_values)
+    if y_train is not None:
+        classes = np.unique(y_train)
     else:
         classes = None
 
@@ -138,7 +138,7 @@ def _get_valid_crisp_predictions(predictions, train_y_values=None, threshold=0.5
     return predictions
 
 
-def validate_predictions(quantifier: Any, predictions: np.ndarray, threshold: float = 0.5, train_y_values=None) -> np.ndarray:
+def validate_predictions(quantifier: Any, predictions: np.ndarray, threshold: float = 0.5, y_train=None) -> np.ndarray:
     """
     Validate predictions using the quantifier's declared output tags.
     Raises InputValidationError if inconsistent with tags.
@@ -158,7 +158,7 @@ def validate_predictions(quantifier: Any, predictions: np.ndarray, threshold: fl
             f"Soft predictions for {quantifier.__class__.__name__} must be float, got dtype {predictions.dtype}."
         )
     elif estimator_type == "crisp" and np.issubdtype(predictions.dtype, np.floating):
-        predictions = _get_valid_crisp_predictions(predictions, train_y_values, threshold) 
+        predictions = _get_valid_crisp_predictions(predictions, y_train, threshold) 
     return predictions   
     
     

{mlquantify-0.1.22.dist-info → mlquantify-0.1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlquantify
-Version: 0.1.22
+Version: 0.1.24
 Summary: Quantification Library
 Home-page: https://github.com/luizfernandolj/QuantifyML/tree/master
 Maintainer: Luiz Fernando Luth Junior

{mlquantify-0.1.22.dist-info → mlquantify-0.1.24.dist-info}/RECORD

@@ -1,16 +1,16 @@
-mlquantify/__init__.py,sha256=gFtdd0MKMje_yVztHzEsKA3p-JF90bO-VQxzSplyovU,348
+mlquantify/__init__.py,sha256=eP8dPDFIUnnLlS3GoleXDGqk-Qb7weZ1xZ6oGpLj32A,384
 mlquantify/base.py,sha256=o7IaKODocyi4tEmCvGmHKQ8F4ZJsaEh4kymsNcLyHAg,5077
 mlquantify/base_aggregative.py,sha256=uqfhpUmgv5pNLLvqgROCWHfjs3sj_2jfwOTyzUySuGo,7545
 mlquantify/calibration.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
-mlquantify/confidence.py,sha256=QkEWr6s-Su3Nbinia_TRQbBeTM6ymDPe7Bv204XBKKA,10799
+mlquantify/confidence.py,sha256=tTEAIsqLUw4ywo-XxnWn7Rcb9uFxgU1r1Tuuf_XwAaY,10876
 mlquantify/multiclass.py,sha256=wFbbXKqGsFVSsI9zC0EHGYyyx1JRxFpzMi_q8l80TUM,11770
 mlquantify/adjust_counting/__init__.py,sha256=3Qsgd-UN-qTv2jO47CzgGZ56dubQ3E7u_L4fBfz7i0o,309
-mlquantify/adjust_counting/_adjustment.py,sha256=GKvJafMHmONQIhY9Dl2Stoy2ROOZWYWaFZqtRUk6ERY,29430
-mlquantify/adjust_counting/_base.py,sha256=gZtxyMut5CFgQChlWQyNtMR5xkq9NbMmtf3mgS_h060,9425
-mlquantify/adjust_counting/_counting.py,sha256=90Rah5E8lfQrathH7Bw4E1-v7Wt-gsI6Rc6t0CD7Btk,5779
+mlquantify/adjust_counting/_adjustment.py,sha256=8wu_QQ4UAdYMqdIwRKeM9gb7bbLT0cIQo8oIaCGlxI4,31209
+mlquantify/adjust_counting/_base.py,sha256=8bC6i2H2qpUiJbLZUkzTHmc12yDB89C7CdSTT1ge6b0,10467
+mlquantify/adjust_counting/_counting.py,sha256=XZRUPL6U6UNXNfpYfOGCrQPH5krb247pwswzaBZjDkA,7220
 mlquantify/adjust_counting/_utils.py,sha256=DEPNzvcr0KszCnfUJaRzBilwWzuNVMSdy5eV7aQ_JPE,2907
 mlquantify/likelihood/__init__.py,sha256=vkeh_5Mb6MFcz3BZTR4MLwO5AU5Qgr_2y9uWmb9uyEQ,35
-mlquantify/likelihood/_classes.py,sha256=RUFd2cfGV9DTeRJ4g2OI3BFwRupyC3XixwR_zpDkqfg,9713
+mlquantify/likelihood/_classes.py,sha256=zhoGYb7Cz9PLaiGveYVzKl6sxPnEdRjj6mN1JLAe368,9864
 mlquantify/meta/__init__.py,sha256=GzdGw4ky_kmd5VNWiLBULy06IdN_MLCDAuJKbnMOx4s,62
 mlquantify/meta/_classes.py,sha256=RwM7UmfcWpdLDMCF4CFOjjPLP0U8h0R-qwwjnR3y34Q,30807
 mlquantify/metrics/__init__.py,sha256=3bzzjSYTgrZIJsfAgJidQlB-bnjInwVYUvJ34bPhZxY,186
@@ -33,7 +33,7 @@ mlquantify/neighbors/_kde.py,sha256=x6DkONFhCec44HPFY5H2DTXjMVKPQkz2kEUmfxx5DrM,
 mlquantify/neighbors/_utils.py,sha256=CozcKtmd6ZDluMT4bvOj4QI7xwORF_vCIJRucPEzJJo,4123
 mlquantify/neural/__init__.py,sha256=UFHkMnUCyqi6zmH6YZr6aTq8v0ndbzTWS9se14rSEx8,28
 mlquantify/neural/_base.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mlquantify/neural/_classes.py,sha256=PCX4-LH3QhgEav44u12bhP_T1BHGNoNcB2aVJ4VWIXk,23373
+mlquantify/neural/_classes.py,sha256=gCWC-6kfZOj20CjB1pnquoKF9mDkVutle3hNhtniYsc,23276
 mlquantify/neural/_perm_invariant.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mlquantify/neural/_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mlquantify/utils/__init__.py,sha256=4_Mnerh2GV6mOiKYW9SX_mjMTxqKeai0umBCnVj4vow,1370
@@ -48,10 +48,10 @@ mlquantify/utils/_parallel.py,sha256=XotpX9nsj6nW-tNCmZ-ahTcRztgnn9oQKP2cl1rLdYM
 mlquantify/utils/_random.py,sha256=7F3nyy7Pa_kN8xP8P1L6MOM4WFu4BirE7bOfGTZ1Spk,1275
 mlquantify/utils/_sampling.py,sha256=3W0vUuvLvoYrt-BZpSM0HM1XJEZr0XYIdkOcUP5hp-8,8350
 mlquantify/utils/_tags.py,sha256=Rz78TLpxgVxBKS0mKTlC9Qo_kn6HaEwVKNXh8pxFT7M,1095
-mlquantify/utils/_validation.py,sha256=V3y-wbH69yFdogcEtQ15ShvtIrlIZ4ObzduaqLYvXp0,18319
+mlquantify/utils/_validation.py,sha256=0k0QiJjG-IFkEHD3A2m1KqKs-LHspI0KimVbXTZTwCM,18284
 mlquantify/utils/prevalence.py,sha256=LG-KXJ5Eb4w26WMpu4PoBpxMSHaqrmTQqdRlyqNRJ1o,2020
-mlquantify-0.1.22.dist-info/licenses/LICENSE,sha256=DyKiou3Tffi-9NKcNBomiuHedeiF9sDC2Y9tZK_3Sko,1539
-mlquantify-0.1.22.dist-info/METADATA,sha256=Smq1DW-R4IAu7X1ZXxxYy68_oMeoguVhFvDTcyaYdjk,4791
-mlquantify-0.1.22.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mlquantify-0.1.22.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
-mlquantify-0.1.22.dist-info/RECORD,,
+mlquantify-0.1.24.dist-info/licenses/LICENSE,sha256=DyKiou3Tffi-9NKcNBomiuHedeiF9sDC2Y9tZK_3Sko,1539
+mlquantify-0.1.24.dist-info/METADATA,sha256=Mu2on_TGVutyh3OtXNVUjYjgf20kCxP9m73JlEjSRwY,4791
+mlquantify-0.1.24.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mlquantify-0.1.24.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
+mlquantify-0.1.24.dist-info/RECORD,,