mlquantify 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

mlquantify/mixture/_utils.py

@@ -6,7 +6,7 @@ import numpy as np
 # =====================================================
 
 def getHist(scores, nbins):
-    """
+    r"""
     Calculate histogram-like bin probabilities for a given set of scores.
 
     This function divides the score range into equal bins and computes the proportion 
@@ -42,7 +42,7 @@ def getHist(scores, nbins):
 
 
 def ternary_search(left: float, right: float, func, tol: float = 1e-4) -> float:
-    """
+    r"""
     Ternary search to find the minimum of a unimodal function in [left, right].
 
     Parameters
@@ -53,8 +53,8 @@ def ternary_search(left: float, right: float, func, tol: float = 1e-4) -> float:
         Right bound.
     func : callable
         Function to minimize.
-    tol : float
-        Tolerance for termination.
+    tol : float, optional
+        Tolerance for termination. Default is 1e-4.
 
     Returns
     -------
@@ -73,10 +73,23 @@ def ternary_search(left: float, right: float, func, tol: float = 1e-4) -> float:
 
 
 def topsoe(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Topsoe distance between two probability distributions.
 
-    D_T(p, q) = sum( p*log(2p/(p+q)) + q*log(2q/(p+q)) )
+    .. math::
+        D_T(p, q) = \sum \left( p \log \frac{2p}{p + q} + q \log \frac{2q}{p + q} \right)
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First probability distribution.
+    q : np.ndarray
+        Second probability distribution.
+
+    Returns
+    -------
+    float
+        The Topsoe distance.
     """
     p = np.maximum(p, 1e-20)
     q = np.maximum(q, 1e-20)
@@ -84,10 +97,23 @@ def topsoe(p: np.ndarray, q: np.ndarray) -> float:
 
 
 def probsymm(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Probabilistic Symmetric distance.
 
-    D_PS(p, q) = sum( (p - q) * log(p / q) )
+    .. math::
+        D_{PS}(p, q) = \sum (p - q) \log \frac{p}{q}
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First probability distribution.
+    q : np.ndarray
+        Second probability distribution.
+
+    Returns
+    -------
+    float
+        The Probabilistic Symmetric distance.
     """
     p = np.maximum(p, 1e-20)
     q = np.maximum(q, 1e-20)
@@ -95,10 +121,23 @@ def probsymm(p: np.ndarray, q: np.ndarray) -> float:
 
 
 def hellinger(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Hellinger distance between two probability distributions.
 
-    H(p, q) = (1/sqrt(2)) * sqrt( sum( (sqrt(p) - sqrt(q))^2 ) )
+    .. math::
+        H(p, q) = \frac{1}{\sqrt{2}} \sqrt{\sum \left( \sqrt{p} - \sqrt{q} \right)^2}
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First probability distribution.
+    q : np.ndarray
+        Second probability distribution.
+
+    Returns
+    -------
+    float
+        The Hellinger distance.
     """
     p = np.maximum(p, 1e-20)
     q = np.maximum(q, 1e-20)
@@ -106,7 +145,19 @@ def hellinger(p: np.ndarray, q: np.ndarray) -> float:
 
 
 def sqEuclidean(p: np.ndarray, q: np.ndarray) -> float:
-    """
+    r"""
     Squared Euclidean distance between two vectors.
+
+    Parameters
+    ----------
+    p : np.ndarray
+        First vector.
+    q : np.ndarray
+        Second vector.
+
+    Returns
+    -------
+    float
+        The squared Euclidean distance.
     """
     return np.sum((p - q) ** 2)

mlquantify/model_selection/_protocol.py

@@ -15,7 +15,7 @@ import numpy as np
 
     
 class BaseProtocol(ProtocolMixin, BaseQuantifier):
-    """Base class for evaluation protocols.
+    r"""Base class for evaluation protocols.
     
     Parameters
     ----------
@@ -76,7 +76,7 @@ class BaseProtocol(ProtocolMixin, BaseQuantifier):
                  
 
     def split(self, X: np.ndarray, y: np.ndarray):
-        """
+        r"""
         Split the data into samples for evaluation.
 
         Parameters
@@ -117,7 +117,7 @@ class BaseProtocol(ProtocolMixin, BaseQuantifier):
 
 
 class APP(BaseProtocol):
-    """
+    r"""
     Artificial Prevalence Protocol (APP) for exhaustive prevalent batch evaluation.
     
     Generates batches with artificially imposed prevalences across all possible 
@@ -185,7 +185,7 @@ class APP(BaseProtocol):
             
 
 class NPP(BaseProtocol):
-    """
+    r"""
     Natural Prevalence Protocol (NPP) that samples data without imposing prevalence constraints.
     
     This protocol simply samples batches randomly with replacement, 
@@ -230,7 +230,7 @@ class NPP(BaseProtocol):
             
 
 class UPP(BaseProtocol):
-    """
+    r"""
     Uniform Prevalence Protocol (UPP) for uniform sampling of artificial prevalences.
     
     Similar to APP, but uses uniform prevalence distribution generation
@@ -310,7 +310,7 @@ class UPP(BaseProtocol):
 
 
 class PPP(BaseProtocol):
-    """
+    r"""
     Personalized Prevalence Protocol (PPP) for targeted prevalence batch generation.
     
     Generates batches with user-specified prevalence distributions, allowing for

mlquantify/model_selection/_search.py

@@ -18,7 +18,7 @@ from mlquantify.model_selection import (
 )
 
 class GridSearchQ(MetaquantifierMixin, BaseQuantifier):
-    """
+    r"""
     Grid Search for Quantifiers with evaluation protocols.
 
     This class automates the hyperparameter search over a grid of parameter

mlquantify/neighbors/_base.py

@@ -13,94 +13,64 @@ from mlquantify.utils._validation import validate_prevalences
 EPS = 1e-12
 
 class BaseKDE(SoftLearnerQMixin, AggregationMixin, BaseQuantifier):
-    r"""
-    Base class for KDEy quantification methods.
-    
-    KDEy methods model the class-conditional densities of posterior probabilities
-    using Kernel Density Estimation (KDE) in the probability simplex space.
-    Given a probabilistic classifier's posterior outputs, each class distribution
-    is approximated as a smooth density function via KDE. Class prevalences in
-    the test set are estimated as the mixture weights of these densities that best 
-    explain the test posterior distribution.
-    
-    Formally, KDEy approximates the test posterior distribution as:
+    r"""Base class for KDEy quantification methods.
 
-    \[
-    p_{test}(x) \approx \sum_{k=1}^K \alpha_k p_k(x),
-    \]
+    KDEy models the class-conditional densities of posterior probabilities using Kernel Density Estimation (KDE)
+    on the probability simplex. Given posterior outputs from a probabilistic classifier, each class distribution
+    is approximated as a smooth KDE. Test set class prevalences correspond to mixture weights that best explain 
+    the overall test posterior distribution.
 
-    where \( p_k(x) \) is the KDE of the posterior scores of class \( k \) on training data,
-    and \( \alpha_k \) are the unknown class prevalences to be estimated under:
+    Mathematically, the test posterior distribution is approximated as:
 
-    \[
-    \alpha_k \geq 0, \quad \sum_{k=1}^K \alpha_k = 1.
-    \]
-    
-    The quantification task is then to find the vector \( \boldsymbol{\alpha} = (\alpha_1,\dots,\alpha_K) \)
-    minimizing an objective function defined on the mixture density and the test posteriors,
-    subject to the simplex constraints on \( \boldsymbol{\alpha} \).
+    .. math::
+
+        p_{\mathrm{test}}(x) \approx \sum_{k=1}^K \alpha_k p_k(x),
+
+    where \(p_k(x)\) is the KDE of class \(k\) posteriors from training data, and \(\alpha_k\) are the unknown class 
+    prevalences subject to:
+
+    .. math::
+
+        \alpha_k \geq 0, \quad \sum_{k=1}^K \alpha_k = 1.
+
+    The quantification minimizes an objective \(\mathcal{L}\) over \(\boldsymbol{\alpha} = (\alpha_1, \dots, \alpha_K)\) in the simplex:
+
+    .. math::
+
+        \min_{\boldsymbol{\alpha} \in \Delta^{K-1}} \mathcal{L} \left( \sum_{k=1}^K \alpha_k p_k(x), \hat{p}(x) \right),
+
+    where \(\hat{p}(x)\) is the test posterior distribution (empirical KDE or direct predictions).
+
+    This problem is typically solved using numerical constrained optimization methods.
 
     Attributes
     ----------
     learner : estimator
-        The underlying probabilistic classifier yielding posterior predictions.
+        Probabilistic classifier generating posterior predictions.
     bandwidth : float
-        Bandwidth (smoothing parameter) for the KDE models.
+        KDE bandwidth (smoothing parameter).
     kernel : str
-        Kernel type used in KDE (e.g., 'gaussian').
+        KDE kernel type (e.g., 'gaussian').
     _precomputed : bool
-        Indicates whether KDE models have been fitted on training data.
+        Indicates if KDE models have been fitted.
     best_distance : float or None
-        Stores the best value of the objective (distance or loss) achieved.
-
-    Methods
-    -------
-    fit(X, y, learner_fitted=False)
-        Fits KDE models for each class using posterior predictions of the learner.
-    predict(X)
-        Aggregates learner’s posterior predictions on X to estimate class prevalences.
-    aggregate(predictions, train_predictions, train_y_values)
-        Core estimation method that validates inputs, ensures KDE precomputation,
-        and calls `_solve_prevalences` implemented by subclasses.
-    _fit_kde_models(train_predictions, train_y_values)
-        Fits KDE model per class on training data posteriors.
-    _solve_prevalences(predictions)
-        Abstract method to estimate prevalence vector \( \boldsymbol{\alpha} \) for given posteriors.
-        Must be implemented by subclasses.
+        Best objective value found during estimation.
 
     Examples
     --------
-    To implement a new KDEy quantifier, subclass BaseKDE and implement the method
-    `_solve_prevalences`, which receives posterior predictions and returns a tuple
-
-    (estimated prevalences \(\boldsymbol{\alpha}\), objective value).
+    Subclasses should implement `_solve_prevalences` method returning estimated prevalences and objective value:
 
     >>> class KDEyExample(BaseKDE):
     ...     def _solve_prevalences(self, predictions):
-    ...         # Example: simple uniform prevalences, replace with actual optimization
     ...         n_classes = len(self._class_kdes)
     ...         alpha = np.ones(n_classes) / n_classes
-    ...         obj_val = 0.0  # Replace with actual objective computation
+    ...         obj_val = 0.0  # Placeholder, replace with actual objective
     ...         return alpha, obj_val
 
-    Mathematical formulation for prevalence estimation typically involves optimizing:
-
-    \[
-    \min_{\boldsymbol{\alpha} \in \Delta^{K-1}} \mathcal{L} \bigg( \sum_{k=1}^K \alpha_k p_k(x), \hat{p}(x) \bigg),
-    \]
-
-    where \(\hat{p}(x)\) is the test posterior distribution (empirical KDE or direct predictions),
-    \(\Delta^{K-1}\) is the probability simplex defined by the constraints on \(\boldsymbol{\alpha}\),
-    and \(\mathcal{L}\) is an appropriate divergence or loss function, e.g., negative log-likelihood,
-    Hellinger distance, or Cauchy–Schwarz divergence.
-
-    This optimization is typically solved numerically with constrained methods such as
-    sequential quadratic programming or projected gradient descent.
-
     References
     ----------
-    [1] Moreo, A., et al. (2023). Kernel Density Quantification methods and applications.
-        In *Learning to Quantify*, Springer.
+    .. [1] Moreo, A., et al. (2023). Kernel Density Quantification methods and applications.
+    In *Learning to Quantify*, Springer.
     """
 
     _parameter_constraints = {

mlquantify/neighbors/_classes.py

@@ -10,7 +10,7 @@ from mlquantify.utils._validation import validate_prevalences
 
 
 class PWK(BaseQuantifier):
-    """
+    r"""
     Probabilistic Weighted k-Nearest Neighbor (PWK) Quantifier.
 
     This quantifier leverages the PWKCLF classifier to perform quantification by estimating 
@@ -47,15 +47,6 @@ class PWK(BaseQuantifier):
     learner : PWKCLF
         Underlying probabilistic weighted k-NN classifier.
 
-    Methods
-    -------
-    fit(X, y)
-        Fits the quantifier by training the internal PWKCLF and wrapping it with 
-        Classify & Count quantification.
-    predict(X)
-        Predicts class prevalences for input data using the trained model.
-    classify(X)
-        Returns label predictions by applying the trained PWKCLF classifier.
 
     Examples
     --------

mlquantify/neighbors/_classification.py

@@ -5,8 +5,7 @@ from sklearn.neighbors import NearestNeighbors
 
 
 class PWKCLF:
-    """
-    Probabilistic Weighted k-Nearest Neighbor Classifier (PWKCLF).
+    r"""Probabilistic Weighted k-Nearest Neighbor Classifier (PWKCLF).
 
     A weighted k-nearest neighbor classifier that assigns class probabilities to 
     instances based on neighbor counts weighted by class-specific inverse frequency 
@@ -29,22 +28,16 @@ class PWKCLF:
     y_train : ndarray
         Labels of training samples.
 
-    Methods
-    -------
-    fit(X, y)
-        Fits the k-NN structure and computes class weights.
-    predict(X)
-        Predicts class labels by weighted voting among neighbors.
 
     Notes
     -----
     The class weights are defined as:
 
-    \[
-    w_c = \left( \frac{N_c}{\min_{c'} N_{c'}} \right)^{-\frac{1}{\alpha}},
-    \]
+    .. math::
+
+        w_c = \left( \frac{N_c}{\min_{c'} N_{c'}} \right)^{-\frac{1}{\alpha}},
 
-    where \( N_c \) is the count of class \( c \) in the training set.
+    where :math:`N_c` is the count of class :math:`c` in the training set.
 
     This weighting scheme reduces bias towards majority classes by downweighting them
     in the voting process.

mlquantify/neighbors/_kde.py

@@ -16,17 +16,16 @@ from scipy.optimize import minimize
 # ============================================================
 
 def _optimize_on_simplex(objective, n_classes, x0=None):
-    """
-    Optimize an objective function over the probability simplex.
+    r"""Optimize an objective function over the probability simplex.
     
     This function performs constrained optimization to find the mixture weights
-    \( \alpha \) on the simplex \( \Delta^{n-1} = \{ \alpha \in \mathbb{R}^n : \alpha_i \geq 0, \sum_i \alpha_i = 1 \} \)
+    :math:`\alpha` on the simplex :math:`\Delta^{n-1} = \{ \alpha \in \mathbb{R}^n : \alpha_i \geq 0, \sum_i \alpha_i = 1 \}`
     that minimize the given objective function.
 
     Parameters
     ----------
     objective : callable
-        Function from \( \mathbb{R}^n \to \mathbb{R} \) to minimize.
+        Function from :math:`\mathbb{R}^n \to \mathbb{R}` to minimize.
     n_classes : int
         Dimensionality of the simplex (number of classes).
     x0 : array-like, optional
@@ -59,7 +58,7 @@ def _optimize_on_simplex(objective, n_classes, x0=None):
 # ============================================================
 
 class KDEyML(BaseKDE):
-    """KDEy Maximum Likelihood quantifier.
+    r"""KDEy Maximum Likelihood quantifier.
     
     Models class-conditional densities of posterior probabilities via Kernel Density
     Estimation (KDE) and estimates class prevalences by maximizing the likelihood of 
@@ -80,13 +79,13 @@ class KDEyML(BaseKDE):
     """
 
     def _precompute_training(self, train_predictions, train_y_values):
-        """
+        r"""
         Fit KDE models on class-specific training posterior predictions.
         """
         super()._fit_kde_models(train_predictions, train_y_values)
 
     def _solve_prevalences(self, predictions):
-        """
+        r"""
         Estimate class prevalences by maximizing log-likelihood under KDE mixture.
         
         Parameters
@@ -208,8 +207,7 @@ class KDEyHD(BaseKDE):
 # ============================================================
 
 class KDEyCS(BaseKDE):
-    """
-    KDEy Cauchy-Schwarz Divergence quantifier.
+    r"""KDEy Cauchy-Schwarz Divergence quantifier.
     
     Uses a closed-form solution for minimizing the Cauchy-Schwarz (CS) divergence between
     Gaussian Mixture Models representing class-conditional densities fitted via KDE.

mlquantify/neighbors/_utils.py

@@ -11,17 +11,16 @@ EPS = 1e-12
 # ============================================================
 
 def gaussian_kernel(X, Y, bandwidth):
-    """
-    Compute the Gaussian kernel matrix K(x, y) with specified bandwidth.
+    r"""Compute the Gaussian kernel matrix K(x, y) with specified bandwidth.
 
     This kernel matrix represents the similarity between each pair of points in X and Y,
     computed using the Gaussian (RBF) kernel function:
 
-    \[
-    K(x, y) = \frac{1}{(2 \pi)^{D/2} h^D} \exp\left(- \frac{\|x - y\|^2}{2 h^2}\right)
-    \]
+    .. math::
+
+        K(x, y) = \frac{1}{(2 \pi)^{D/2} h^D} \exp\left(- \frac{\|x - y\|^2}{2 h^2}\right)
 
-    where \( h \) is the bandwidth (smoothing parameter), and \( D \) is the dimensionality
+    where :math:`h` is the bandwidth (smoothing parameter), and :math:`D` is the dimensionality
     of the input feature space.
 
     Parameters
@@ -31,7 +30,7 @@ def gaussian_kernel(X, Y, bandwidth):
     Y : array-like of shape (n_samples_Y, n_features) or None
         Input data points for kernel computation. If None, defaults to X.
     bandwidth : float
-        Kernel bandwidth parameter \( h \).
+        Kernel bandwidth parameter :math:`h`.
 
     Returns
     -------
@@ -50,14 +49,13 @@ def gaussian_kernel(X, Y, bandwidth):
 
 
 def negative_log_likelihood(mixture_likelihoods):
-    """
-    Compute the negative log-likelihood of given mixture likelihoods in a numerically stable way.
+    r"""Compute the negative log-likelihood of given mixture likelihoods in a numerically stable way.
+
+    Given mixture likelihood values :math:`p_i` for samples, the negative log-likelihood is:
 
-    Given mixture likelihood values \( p_i \) for samples, the negative log-likelihood is:
+    .. math::
 
-    \[
-    - \sum_i \log(p_i)
-    \]
+        - \sum_i \log(p_i)
 
     Numerical stability is achieved by clipping likelihoods below a small epsilon.
 
@@ -76,14 +74,13 @@ def negative_log_likelihood(mixture_likelihoods):
 
 
 def _simplex_constraints(n):
-    """
-    Define constraints and bounds for optimization over the probability simplex.
+    r"""Define constraints and bounds for optimization over the probability simplex.
+
+    The simplex is defined as all vectors :math:`\alpha \in \mathbb{R}^n` such that:
 
-    The simplex is defined as all vectors \( \alpha \in \mathbb{R}^n \) such that:
+    .. math::
 
-    \[
-    \alpha_i \geq 0, \quad \sum_{i=1}^n \alpha_i = 1
-    \]
+        \alpha_i \geq 0, \quad \sum_{i=1}^n \alpha_i = 1
 
     Parameters
     ----------
@@ -103,8 +100,7 @@ def _simplex_constraints(n):
 
 
 def _optimize_on_simplex(objective, n, x0=None):
-    """
-    Minimize an objective function over the probability simplex.
+    r"""Minimize an objective function over the probability simplex.
 
     This function solves for mixture weights \( \boldsymbol{\alpha} \) that minimize the 
     objective function under the constraints \(\alpha_i \geq 0\) and \(\sum_i \alpha_i = 1\).

mlquantify/utils/prevalence.py

@@ -3,7 +3,7 @@ import pandas as pd
 from collections import defaultdict
 
 
-def get_prev_from_labels(y) -> dict:
+def get_prev_from_labels(y, format="dict") -> dict:
     """
     Get the real prevalence of each class in the target array.
     
@@ -19,6 +19,9 @@ def get_prev_from_labels(y) -> dict:
     """
     if isinstance(y, np.ndarray):
         y = pd.Series(y)
+    if format == "array":
+        prevalences = y.value_counts(normalize=True).sort_index().values
+        return prevalences
     real_prevs = y.value_counts(normalize=True).to_dict()
     real_prevs = dict(sorted(real_prevs.items()))
     return real_prevs

{mlquantify-0.1.9.dist-info → mlquantify-0.1.10.dist-info}/METADATA

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

mlquantify-0.1.10.dist-info/RECORD

@@ -0,0 +1,53 @@
+mlquantify/__init__.py,sha256=O03s8PZhkTy7V8lOrmHIsGAwI3RPUlUPfeNTVTnU-Q8,326
+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/multiclass.py,sha256=Jux0fvL5IBZA3DXLCuqUEE77JYYBGAcW6GaEH9srmu4,11747
+mlquantify/adjust_counting/__init__.py,sha256=AWio99zeaUULQq9vKggkFhnq-tqgXxasQt167NdcNVY,307
+mlquantify/adjust_counting/_adjustment.py,sha256=JYfPj-x0tw6aLt6m3YehsuKXF6FMUIIvjXImbiqXkGI,23130
+mlquantify/adjust_counting/_base.py,sha256=-nxH0seDXmEW9eGoqrH69JaIUCeNjFKBa8pDDH8u0Tg,9342
+mlquantify/adjust_counting/_counting.py,sha256=7Ip7-XHQJcTWcWVDaLzEIM6WYcp8k5axsCIyD3QPWZE,5572
+mlquantify/adjust_counting/_utils.py,sha256=DEPNzvcr0KszCnfUJaRzBilwWzuNVMSdy5eV7aQ_JPE,2907
+mlquantify/likelihood/__init__.py,sha256=3dC5uregNmquUKz0r0-3aPspfjZjKGn3TRBoZPO1uFs,53
+mlquantify/likelihood/_base.py,sha256=seu_Vb58QttcGbFjHKAplMYGZcVbIHqkyTXEK2cax9A,5830
+mlquantify/likelihood/_classes.py,sha256=PZ31cAwO8q5X3O2_oSmQ1FM6bY4EsB8hWEcAgcEmWXQ,14731
+mlquantify/meta/__init__.py,sha256=GzdGw4ky_kmd5VNWiLBULy06IdN_MLCDAuJKbnMOx4s,62
+mlquantify/meta/_classes.py,sha256=3twKSrm4mF_AXZ1FP0V0hoOo-ceJulGKKgSEBvU8Vt0,30631
+mlquantify/metrics/__init__.py,sha256=3bzzjSYTgrZIJsfAgJidQlB-bnjInwVYUvJ34bPhZxY,186
+mlquantify/metrics/_oq.py,sha256=koXDKeHWksl_vHpZuhc2pAps8wvu_MOgEztlSr04MmE,3544
+mlquantify/metrics/_rq.py,sha256=3yiEmGaRAGpzL29Et3tNqkJ3RMsLXwUX3uL9RoIgi40,3034
+mlquantify/metrics/_slq.py,sha256=JZceO2LR3mjbT_0zVcl9xI6jf8pn3tIcpP3vP3Luf9I,6817
+mlquantify/mixture/__init__.py,sha256=_KKhpFuvi3vYwxydm5nOy9MKwmIU4eyZDN9Pe00hqtk,70
+mlquantify/mixture/_base.py,sha256=1-yW64FPQXB_d9hH9KjSlDnmFtW9FY7S2hppXAd1DBg,5645
+mlquantify/mixture/_classes.py,sha256=uYtWh6oTx0M3rTG71gfO6RWt3QVXH6KN5F-J4YKN0TM,16329
+mlquantify/mixture/_utils.py,sha256=CKlC081nrkJ8Pil7lrPZvNZC_xfpXV8SsuQq3M_LHgA,4037
+mlquantify/model_selection/__init__.py,sha256=98I0uf8k6lbWAjazGyGjbOdPOvzU8aMRLqC3I7D3jzk,113
+mlquantify/model_selection/_protocol.py,sha256=2k0M_7YwZf7YLoQ8ElR2xMvLySVgtE_EvWieMXTIzTA,12499
+mlquantify/model_selection/_search.py,sha256=1UoP3tZ-pdfM25C-gOS89qjGKcDgQEeU7GTbwtsLKHU,10695
+mlquantify/model_selection/_split.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+mlquantify/neighbors/__init__.py,sha256=rIOuSaUhjqEXsUN9HNZ62P53QG0N7lJ3j1pvf8kJzms,93
+mlquantify/neighbors/_base.py,sha256=ZKU2r19mJHUNXT9Y5fDPOib7zUsT5H9cgDEE2MPa0DM,6582
+mlquantify/neighbors/_classes.py,sha256=VxvuULA8O9hL3p0PxeDZkrZmUNbRYen_HsX_BkkzGd0,5234
+mlquantify/neighbors/_classification.py,sha256=8xNqaTQXUGg_dbQd6SqwKWb07BM2QM0uwZeXZ5C_DMs,4136
+mlquantify/neighbors/_kde.py,sha256=g0D8DlebJ5OZETW3SaMWyJUe1AZIytV--yIX3RCu46o,9931
+mlquantify/neighbors/_utils.py,sha256=CozcKtmd6ZDluMT4bvOj4QI7xwORF_vCIJRucPEzJJo,4123
+mlquantify/neural/__init__.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+mlquantify/utils/__init__.py,sha256=fCozxFABSv5L7lbD16-J370dbc_xHien3w0crYKPLTc,1344
+mlquantify/utils/_artificial.py,sha256=6tqMoAuxUULFGHXtMez56re4DZ7d2Q6tK55LPGeEiO8,713
+mlquantify/utils/_constraints.py,sha256=r1WDJuqsO3OS2Q45IBKJGtB6iUjcAXMW8USaEakyvCI,5600
+mlquantify/utils/_context.py,sha256=25QmzmfSiuF_hwCjY_7db_XfCnj1dVe4mIbDycVTHf8,661
+mlquantify/utils/_decorators.py,sha256=yYtnPBh1sLSN6wTY-7ZVAV0j--qbpJxBsgncm794JPc,1205
+mlquantify/utils/_exceptions.py,sha256=C3BQSv3-7QDLaorKcV-ANxnBcSaxHQSlCc6YSZrPK6c,392
+mlquantify/utils/_get_scores.py,sha256=VlTvgg_t4D9MzcgsH7YvP_wIL5AZ8XmEtGpbFivdVJk,5280
+mlquantify/utils/_load.py,sha256=cMGXIs-8mUB4blAmagyDNNvAaV2hysRgeInQMl5fDHg,303
+mlquantify/utils/_parallel.py,sha256=XotpX9nsj6nW-tNCmZ-ahTcRztgnn9oQKP2cl1rLdYM,196
+mlquantify/utils/_random.py,sha256=7F3nyy7Pa_kN8xP8P1L6MOM4WFu4BirE7bOfGTZ1Spk,1275
+mlquantify/utils/_sampling.py,sha256=QQxE2WKLdiCFUfPF6fKgzyrsOUIWYf74w_w8fbYVc2c,8409
+mlquantify/utils/_tags.py,sha256=Rz78TLpxgVxBKS0mKTlC9Qo_kn6HaEwVKNXh8pxFT7M,1095
+mlquantify/utils/_validation.py,sha256=dE7NYLy6C5UWf8tXIhQeWLTz2-rej_gr8-aAIwgJTPk,16762
+mlquantify/utils/prevalence.py,sha256=FXLCJViQb2yDbyTXeGZt8WsPPnSZINhorQYZTKXOn14,1772
+mlquantify-0.1.10.dist-info/METADATA,sha256=qvy3E7u4daj9ZSZnrza7ZtNHcs46xx63wMWbeq4R3T8,5193
+mlquantify-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mlquantify-0.1.10.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
+mlquantify-0.1.10.dist-info/RECORD,,

mlquantify-0.1.9.dist-info/RECORD

@@ -1,53 +0,0 @@
-mlquantify/__init__.py,sha256=P48iiVlcAeKeE6wr6yZGMTKwmtCOvQYO4ZUVCKAQMwM,52
-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=IUF6sLVmDi4XxX5NvbSFl4-cBbl1mdedtDMFqV-GA48,10918
-mlquantify/multiclass.py,sha256=Jux0fvL5IBZA3DXLCuqUEE77JYYBGAcW6GaEH9srmu4,11747
-mlquantify/adjust_counting/__init__.py,sha256=8qQtTzRAoRiIux_R8wCXopdi6dOg1ESd8oPWv-LvUC0,191
-mlquantify/adjust_counting/_adjustment.py,sha256=BdFwYTwWhwdSxBgu98yTsVyyxgPz_Xm53YEjMxXI8f8,12824
-mlquantify/adjust_counting/_base.py,sha256=abF0lo3fetR77JP87MS7Hy204jF7NYdxwyJWPE5hNyE,9344
-mlquantify/adjust_counting/_counting.py,sha256=n4pBdyntrrxZTu7dWMnCsgN5kz6npU7CNIgRPQLY-nA,5266
-mlquantify/adjust_counting/_utils.py,sha256=wlBrihWKPzzxXmIqowreZ_lN6buD6hFCH98qA3H6s5s,2636
-mlquantify/likelihood/__init__.py,sha256=3dC5uregNmquUKz0r0-3aPspfjZjKGn3TRBoZPO1uFs,53
-mlquantify/likelihood/_base.py,sha256=J6ze15i-TlMMEVl4KvE2_wdam-fq0ZqWl7pSkas35qs,6075
-mlquantify/likelihood/_classes.py,sha256=Xp0hU83mYmfs1AOlmGEYLLsBPZBjPoi2xTx-2H4ztuI,15111
-mlquantify/meta/__init__.py,sha256=GzdGw4ky_kmd5VNWiLBULy06IdN_MLCDAuJKbnMOx4s,62
-mlquantify/meta/_classes.py,sha256=msivgTXvPw6Duq2Uv_odoayX-spZPtuWtD0FQ_8UFdw,29824
-mlquantify/metrics/__init__.py,sha256=3bzzjSYTgrZIJsfAgJidQlB-bnjInwVYUvJ34bPhZxY,186
-mlquantify/metrics/_oq.py,sha256=qTLyKpQkdnyzNOmWjplnLnr7nMDNqlBtfnddo5XHJ48,3542
-mlquantify/metrics/_rq.py,sha256=v0FUepNF-Wj0f1MdB1-9TXSNDze-J0BXUqaTCo5gnUA,3032
-mlquantify/metrics/_slq.py,sha256=nigIpZtPhPYVe5GU3qf1TOxGIkmKOrrhLXAm_tDPaCQ,6808
-mlquantify/mixture/__init__.py,sha256=_KKhpFuvi3vYwxydm5nOy9MKwmIU4eyZDN9Pe00hqtk,70
-mlquantify/mixture/_base.py,sha256=VDAOY6vFM2OayQxN4APysZ-ZycfrUwUS5Zzjr5v2t04,6076
-mlquantify/mixture/_classes.py,sha256=BbBrMIFKWoaP5CjW35agecwl3TE6ZmmBh8kwUyp72Ig,14012
-mlquantify/mixture/_utils.py,sha256=3507D13aw6Xl5Ki5bcC1j8yZH4EqawmtRke9m4AouT4,3049
-mlquantify/model_selection/__init__.py,sha256=98I0uf8k6lbWAjazGyGjbOdPOvzU8aMRLqC3I7D3jzk,113
-mlquantify/model_selection/_protocol.py,sha256=J-96OPJCkwtwk96P962qeztENRwypO__SbDLxM-Myvo,12493
-mlquantify/model_selection/_search.py,sha256=YXeSSJXQVrKjwxfKOKJ9amkXZ1mOPJWKh2x2SQNO5rM,10694
-mlquantify/model_selection/_split.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
-mlquantify/neighbors/__init__.py,sha256=rIOuSaUhjqEXsUN9HNZ62P53QG0N7lJ3j1pvf8kJzms,93
-mlquantify/neighbors/_base.py,sha256=tYgq_yjEuqv0dipo2hZW99GxlF09mwpTxlMLV2gYUHo,8258
-mlquantify/neighbors/_classes.py,sha256=zWPn9zhY_Xw3AgC1A112DUO3LrbuKOMvkZU2Cx0elYU,5577
-mlquantify/neighbors/_classification.py,sha256=wzqz6eZpE4AAyBmxv8cjheluoUB_RDYse_mfLCVXfzI,4310
-mlquantify/neighbors/_kde.py,sha256=URCq_o-bSb94_-1jX1Ag-1ZLkP0sBa-D3obAgqN6YYg,9930
-mlquantify/neighbors/_utils.py,sha256=rAu2VuW13rBj935z_m-u0MpfQbLQC0Iq_1WPSnAXZCk,4114
-mlquantify/neural/__init__.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
-mlquantify/utils/__init__.py,sha256=fCozxFABSv5L7lbD16-J370dbc_xHien3w0crYKPLTc,1344
-mlquantify/utils/_artificial.py,sha256=6tqMoAuxUULFGHXtMez56re4DZ7d2Q6tK55LPGeEiO8,713
-mlquantify/utils/_constraints.py,sha256=r1WDJuqsO3OS2Q45IBKJGtB6iUjcAXMW8USaEakyvCI,5600
-mlquantify/utils/_context.py,sha256=25QmzmfSiuF_hwCjY_7db_XfCnj1dVe4mIbDycVTHf8,661
-mlquantify/utils/_decorators.py,sha256=yYtnPBh1sLSN6wTY-7ZVAV0j--qbpJxBsgncm794JPc,1205
-mlquantify/utils/_exceptions.py,sha256=C3BQSv3-7QDLaorKcV-ANxnBcSaxHQSlCc6YSZrPK6c,392
-mlquantify/utils/_get_scores.py,sha256=VlTvgg_t4D9MzcgsH7YvP_wIL5AZ8XmEtGpbFivdVJk,5280
-mlquantify/utils/_load.py,sha256=cMGXIs-8mUB4blAmagyDNNvAaV2hysRgeInQMl5fDHg,303
-mlquantify/utils/_parallel.py,sha256=XotpX9nsj6nW-tNCmZ-ahTcRztgnn9oQKP2cl1rLdYM,196
-mlquantify/utils/_random.py,sha256=7F3nyy7Pa_kN8xP8P1L6MOM4WFu4BirE7bOfGTZ1Spk,1275
-mlquantify/utils/_sampling.py,sha256=QQxE2WKLdiCFUfPF6fKgzyrsOUIWYf74w_w8fbYVc2c,8409
-mlquantify/utils/_tags.py,sha256=Rz78TLpxgVxBKS0mKTlC9Qo_kn6HaEwVKNXh8pxFT7M,1095
-mlquantify/utils/_validation.py,sha256=dE7NYLy6C5UWf8tXIhQeWLTz2-rej_gr8-aAIwgJTPk,16762
-mlquantify/utils/prevalence.py,sha256=9chdjfUyac7Omxv50Rb_HmfkQFrHfTjGiQPdbVH7FXc,1631
-mlquantify-0.1.9.dist-info/METADATA,sha256=QZUSlEfWxeFGjI8R1QzJx5Y4DeyCiWjFqxFHQzYEIz0,5192
-mlquantify-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mlquantify-0.1.9.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
-mlquantify-0.1.9.dist-info/RECORD,,