mlquantify 0.0.11.8__tar.gz → 0.0.11.10__tar.gz

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/PKG-INFO

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

mlquantify-0.0.11.10/mlquantify/__init__.py

@@ -0,0 +1,30 @@
+"mlquantify, a Python package for quantification"
+
+from . import base
+from . import model_selection
+from . import plots
+from . import classification
+from . import evaluation
+from . import methods
+from . import utils
+
+ARGUMENTS_SETTED = False
+
+arguments = {
+    "y_pred": None,
+    "posteriors_train": None,
+    "posteriors_test": None,
+    "y_labels": None,
+    "y_pred_train": None,
+}
+
+def set_arguments(y_pred=None, posteriors_train=None, posteriors_test=None,  y_labels=None, y_pred_train=None):
+    global ARGUMENTS_SETTED
+    global arguments
+    arguments["y_pred"] = y_pred
+    arguments["posteriors_train"] = posteriors_train
+    arguments["posteriors_test"] = posteriors_test
+    arguments["y_labels"] = y_labels
+    arguments["y_pred_train"] = y_pred_train
+    
+    ARGUMENTS_SETTED = True

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify/base.py

@@ -4,7 +4,7 @@ from copy import deepcopy
 import numpy as np
 import joblib
 
-
+import mlquantify as mq
 from .utils.general import parallel, normalize_prevalence
 
 class Quantifier(ABC, BaseEstimator):
@@ -271,6 +271,18 @@ class AggregativeQuantifier(Quantifier, ABC):
 
         ...
     
+    @property
+    def is_probabilistic(self) -> bool:
+        """Check if the learner is probabilistic or not.
+        
+        Returns
+        -------
+        bool
+            True if the learner is probabilistic, False otherwise.
+        """
+        return False
+    
+    
     @property
     def learner(self):
         """Returns the learner_ object.
@@ -289,9 +301,52 @@ class AggregativeQuantifier(Quantifier, ABC):
         value : any
             The value to be assigned to the learner_ attribute.
         """
-        
+        assert isinstance(value, BaseEstimator) or mq.ARGUMENTS_SETTED, "learner object is not an estimator, or you may change ARGUMENTS_SETTED to True"
         self.learner_ = value
+    
+    def fit_learner(self, X, y):
+        """Fit the learner to the training data.
         
+        Parameters
+        ----------
+        X : array-like
+            Training features.
+        y : array-like
+            Training labels.
+        """
+        if mq.ARGUMENTS_SETTED:
+            if self.is_probabilistic and mq.arguments["posteriors_test"] is not None:
+                return
+            elif not self.is_probabilistic and mq.arguments["y_pred"] is not None:
+                return
+        else:
+            if not self.learner_fitted:
+                self.learner_.fit(X, y)
+
+    def predict_learner(self, X):
+        """Predict the class labels or probabilities for the given data.
+        
+        Parameters
+        ----------
+        X : array-like
+            Test features.
+        
+        Returns
+        -------
+        array-like
+            The predicted class labels or probabilities.
+        """
+        if self.learner is not None:
+            if self.is_probabilistic:
+                return self.learner_.predict_proba(X)
+            return self.learner_.predict(X)
+        else:
+            if mq.ARGUMENTS_SETTED:
+                if self.is_probabilistic:
+                    return mq.arguments["posteriors_test"]
+                return mq.arguments["y_pred"]
+            else:
+                raise ValueError("No learner object was set and no arguments were setted")
 
     def set_params(self, **params):
         """

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify/evaluation/protocol.py

@@ -12,6 +12,8 @@ from ..utils.method import *
 from . import MEASURES
 from ..base import Quantifier
 
+import mlquantify as mq
+
 class Protocol(ABC):
     """Base class for evaluation protocols.
     
@@ -198,7 +200,6 @@ class Protocol(ABC):
         if isinstance(models, list):
             if all(isinstance(model, Quantifier) for model in models):
                 return models
-            assert learner is not None, "Learner is required for model methods."
             return [get_method(model)(learner) for model in models]
         
         if isinstance(models, Quantifier):
@@ -214,7 +215,6 @@ class Protocol(ABC):
 
         if models in model_dict:
             return [model(learner) if hasattr(model, "learner") else model() for model in model_dict[models]()]
-        
         return [get_method(models)(learner)]
     
     def sout(self, msg):
@@ -240,12 +240,12 @@ class Protocol(ABC):
         self.sout("Fitting models")
 
         args = ((model, X_train, y_train) for model in self.models)
+        
         wrapper = tqdm if self.verbose else lambda x, **kwargs: x
 
-        self.models = Parallel(n_jobs=self.n_jobs)(  # Parallel processing of models
+        self.models = Parallel(n_jobs=self.n_jobs, backend='threading')(  # Parallel processing of models
             delayed(self._delayed_fit)(*arg) for arg in wrapper(args, desc="Fitting models", total=len(self.models))
         )
-
         self.sout("Fit [Done]")
         return self
     
@@ -336,10 +336,14 @@ class Protocol(ABC):
         Quantifier
             Fitted quantification model
         """
+        model_name = model.__class__.__name__
+        if model_name == "Ensemble" and isinstance(model.base_quantifier, Quantifier):
+            model_name = f"{model.__class__.__name__}_{model.base_quantifier.__class__.__name__}_{model.size}"
+        
         start = time()
         model = model.fit(X=X_train, y=y_train)
         duration = time() - start
-        print(f"\tFitted {model.__class__.__name__} in {duration:.3f} seconds")
+        print(f"\tFitted {model_name} in {duration:.3f} seconds")
         return model
 
 
@@ -520,6 +524,8 @@ class APP(Protocol):
             Tuple containing the iteration, model name, prev, prev_pred, and batch size.
         """
         model_name = model.__class__.__name__
+        if model_name == "Ensemble" and isinstance(model.base_quantifier, Quantifier):
+            model_name = f"{model.__class__.__name__}_{model.base_quantifier.__class__.__name__}_{model.size}"
         
         if verbose:
             print(f'\t {model_name} with {batch_size} instances and prev {prev}')

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify/methods/aggregative.py

@@ -7,6 +7,7 @@ from ..utils.method import *
 from sklearn.base import BaseEstimator
 from sklearn.metrics import confusion_matrix
 from sklearn.model_selection import train_test_split
+import mlquantify as mq
 
 
 
@@ -75,8 +76,7 @@ class CC(AggregativeQuantifier):
     {0: 0.4166666666666667, 1: 0.3194444444444444, 2: 0.2638888888888889}
     """
     
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
     
     def _fit_method(self, X, y):
@@ -95,8 +95,7 @@ class CC(AggregativeQuantifier):
         self : CC
             The instance of the CC class.
         """
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
+        self.fit_learner(X, y)
         return self
     
     def _predict_method(self, X) -> np.ndarray:
@@ -114,7 +113,7 @@ class CC(AggregativeQuantifier):
         array-like
             An array containing the prevalence of each class.
         """
-        predicted_labels = self.learner.predict(X)
+        predicted_labels = self.predict_learner(X)
         
         # Count occurrences of each class in the predictions
         class_counts = np.array([np.count_nonzero(predicted_labels == _class) for _class in self.classes])
@@ -147,13 +146,6 @@ class EMQ(AggregativeQuantifier):
     priors : array-like
         Prior probabilities of the classes, estimated from the training data.
     
-    Constants
-    ---------
-    MAX_ITER : int
-        The maximum number of iterations allowed for the EM algorithm (default: 1000).
-    EPSILON : float
-        Convergence threshold for the EM algorithm (default: 1e-6).
-    
     References
     ----------
     SAERENS, Marco; LATINNE, Patrice; DECAESTECKER, Christine. Adjusting the outputs of a classifier 
@@ -184,8 +176,11 @@ class EMQ(AggregativeQuantifier):
     MAX_ITER = 1000
     EPSILON = 1e-6
     
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    @property
+    def is_probabilistic(self) -> bool:
+        return True
+    
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
         self.priors = None
     
@@ -205,9 +200,8 @@ class EMQ(AggregativeQuantifier):
         self : EMQ
             The fitted instance of EMQ.
         """
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
-        
+        self.fit_learner(X, y)
+         
         counts = np.array([np.count_nonzero(y == _class) for _class in self.classes])
         self.priors = counts / len(y)
         
@@ -227,7 +221,7 @@ class EMQ(AggregativeQuantifier):
         dict
             A dictionary with class labels as keys and their prevalence as values.
         """
-        posteriors = self.learner.predict_proba(X)
+        posteriors = self.predict_learner(X)
         prevalences, _ = self.EM(self.priors, posteriors)
         
         return prevalences
@@ -250,7 +244,7 @@ class EMQ(AggregativeQuantifier):
         np.ndarray
             Adjusted posterior probabilities.
         """
-        posteriors = self.learner.predict_proba(X)
+        posteriors = self.predict_learner(X)
         _, posteriors = self.EM(self.priors, posteriors, epsilon, max_iter)
         return posteriors
     
@@ -360,8 +354,13 @@ class FM(AggregativeQuantifier):
     >>> get_real_prev(y_test)
     {0: 0.4166666666666667, 1: 0.3194444444444444, 2: 0.2638888888888889}
     """
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    
+    @property
+    def is_probabilistic(self) -> bool:
+        return True
+    
+    
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
         self.CM = None
     
@@ -386,11 +385,14 @@ class FM(AggregativeQuantifier):
             The fitted instance of FM.
         """
         # Get predicted labels and probabilities using cross-validation
-        y_labels, probabilities = get_scores(X, y, self.learner, self.cv_folds, self.learner_fitted)
+        if mq.arguments["y_labels"] is not None and mq.arguments["posteriors_train"] is not None:
+            y_labels = mq.arguments["y_labels"]
+            probabilities = mq.arguments["posteriors_train"]
+        else:
+            y_labels, probabilities = get_scores(X, y, self.learner, self.cv_folds, self.learner_fitted)
         
         # Fit the learner if it hasn't been fitted already
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
+        self.fit_learner(X, y)
         
         # Initialize the confusion matrix
         CM = np.zeros((self.n_class, self.n_class))
@@ -426,7 +428,7 @@ class FM(AggregativeQuantifier):
         dict
             A dictionary with class labels as keys and their prevalence as values.
         """
-        posteriors = self.learner.predict_proba(X)
+        posteriors = self.predict_learner(X)
         
         # Calculate the estimated prevalences in the test set
         prevs_estim = np.sum(posteriors > self.priors, axis=0) / posteriors.shape[0]
@@ -518,8 +520,7 @@ class GAC(AggregativeQuantifier):
     """
 
     
-    def __init__(self, learner: BaseEstimator, train_size:float=0.6, random_state:int=None):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None, train_size:float=0.6, random_state:int=None):
         self.learner = learner
         self.cond_prob_matrix = None
         self.train_size = train_size
@@ -546,14 +547,14 @@ class GAC(AggregativeQuantifier):
         if isinstance(y, np.ndarray):
             y = pd.Series(y)
 
-        if self.learner_fitted:
-            y_pred = self.learner.predict(X)
+        if self.learner_fitted or self.learner is None:
+            y_pred = mq.arguments["y_pred_train"] if mq.arguments["y_pred_train"] is not None else self.predict_learner(X)
             y_label = y
         else:
             X_train, X_val, y_train, y_val = train_test_split(
                 X, y, train_size=self.train_size, stratify=y, random_state=self.random_state
             )
-            self.learner.fit(X_train, y_train)
+            self.fit_learner(X_train, y_train)
             y_label = y_val
             y_pred = self.learner.predict(X_val)
 
@@ -574,7 +575,7 @@ class GAC(AggregativeQuantifier):
         dict
             Adjusted class prevalences.
         """
-        y_pred = self.learner.predict(X)
+        y_pred = self.predict_learner(X)
         _, counts = np.unique(y_pred, return_counts=True)
         predicted_prevalences = counts / counts.sum()
         adjusted_prevalences = self.solve_adjustment(self.cond_prob_matrix, predicted_prevalences)
@@ -702,8 +703,7 @@ class GPAC(AggregativeQuantifier):
     {0: 0.4166666666666667, 1: 0.3194444444444444, 2: 0.2638888888888889}
     """
 
-    def __init__(self, learner: BaseEstimator, train_size: float = 0.6, random_state: int = None):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None, train_size: float = 0.6, random_state: int = None):
         self.learner = learner
         self.cond_prob_matrix = None
         self.train_size = train_size
@@ -730,16 +730,16 @@ class GPAC(AggregativeQuantifier):
         if isinstance(y, np.ndarray):
             y = pd.Series(y)
 
-        if self.learner_fitted:
-            y_pred = self.learner.predict(X)
+        if self.learner_fitted or self.learner is None:
+            y_pred = mq.arguments["y_pred_train"] if mq.arguments["y_pred_train"] is not None else self.predict_learner(X)
             y_labels = y
         else:
             X_train, X_val, y_train, y_val = train_test_split(
                 X, y, train_size=self.train_size, stratify=y, random_state=self.random_state
             )
-            self.learner.fit(X_train, y_train)
+            self.fit_learner(X_train, y_train)
             y_labels = y_val
-            y_pred = self.learner.predict(X_val)
+            y_pred = self.predict_learner(X_val)
 
         # Compute the conditional probability matrix
         self.cond_prob_matrix = GAC.get_cond_prob_matrix(self.classes, y_labels, y_pred)
@@ -759,7 +759,7 @@ class GPAC(AggregativeQuantifier):
         dict
             Adjusted class prevalences.
         """
-        predictions = self.learner.predict(X)
+        predictions = self.predict_learner(X)
 
         # Compute the distribution of predictions
         predicted_prevalences = np.zeros(self.n_class)
@@ -851,9 +851,11 @@ class PCC(AggregativeQuantifier):
     >>> get_real_prev(y_test)
     {0: 0.4166666666666667, 1: 0.3194444444444444, 2: 0.2638888888888889}
     """
+    @property
+    def is_probabilistic(self) -> bool:
+        return True
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
 
     def _fit_method(self, X, y):
@@ -872,8 +874,7 @@ class PCC(AggregativeQuantifier):
         self : PCC
             Fitted quantifier object.
         """
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
+        self.fit_learner(X, y)
         return self
 
     def _predict_method(self, X) -> np.ndarray:
@@ -896,7 +897,7 @@ class PCC(AggregativeQuantifier):
         # Calculate the prevalence for each class
         for class_index in range(self.n_class):
             # Get the predicted probabilities for the current class
-            class_probabilities = self.learner.predict_proba(X)[:, class_index]
+            class_probabilities = self.predict_learner(X)[:, class_index]
 
             # Compute the average probability (prevalence) for the current class
             mean_prev = np.mean(class_probabilities)
@@ -954,8 +955,7 @@ class PWK(AggregativeQuantifier):
     {0: 0.4166666666666667, 1: 0.3194444444444444, 2: 0.2638888888888889}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
 
     def _fit_method(self, X, y):
@@ -974,8 +974,7 @@ class PWK(AggregativeQuantifier):
         self : PWK
             Fitted quantifier object.
         """
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
+        self.fit_learner(X, y)
         return self
 
     def _predict_method(self, X) -> dict:
@@ -993,7 +992,7 @@ class PWK(AggregativeQuantifier):
             A dictionary mapping each class label to its estimated prevalence.
         """
         # Predict class labels for the given data
-        predicted_labels = self.learner.predict(X)
+        predicted_labels = self.predict_learner(X)
 
         # Compute the distribution of predicted labels
         unique_labels, label_counts = np.unique(predicted_labels, return_counts=True)

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify/methods/mixture_models.py

@@ -6,6 +6,7 @@ from ..base import AggregativeQuantifier
 
 from ..utils.general import get_real_prev
 from ..utils.method import *
+import mlquantify as mq
 
 
 
@@ -69,7 +70,7 @@ class MixtureModel(AggregativeQuantifier):
     {0: 0.37719298245614036, 1: 0.6228070175438597}
     """
 
-    def __init__(self, learner: BaseEstimator):
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
         self.pos_scores = None
         self.neg_scores = None
@@ -85,6 +86,10 @@ class MixtureModel(AggregativeQuantifier):
             Always returns False, as MixtureModel supports only binary classification.
         """
         return False
+    
+    @property
+    def is_probabilistic(self) -> bool:
+        return True
 
     def _fit_method(self, X, y):
         """
@@ -102,11 +107,15 @@ class MixtureModel(AggregativeQuantifier):
         self : MixtureModel
             The fitted MixtureModel instance.
         """
-        y_label, probabilities = get_scores(X, y, self.learner, self.cv_folds, self.learner_fitted)
+        if mq.arguments["y_labels"] is not None and mq.arguments["posteriors_train"] is not None:
+            y_labels = mq.arguments["y_labels"]
+            probabilities = mq.arguments["posteriors_train"]
+        else:
+            y_labels, probabilities = get_scores(X, y, self.learner, self.cv_folds, self.learner_fitted)
 
         # Separate positive and negative scores based on labels
-        self.pos_scores = probabilities[y_label == self.classes[1]][:, 1]
-        self.neg_scores = probabilities[y_label == self.classes[0]][:, 1]
+        self.pos_scores = probabilities[y_labels == self.classes[1]][:, 1]
+        self.neg_scores = probabilities[y_labels == self.classes[0]][:, 1]
 
         return self
 
@@ -125,7 +134,7 @@ class MixtureModel(AggregativeQuantifier):
             An array containing the prevalence for each class.
         """
         # Get the predicted probabilities for the positive class
-        test_scores = self.learner.predict_proba(X)[:, 1]
+        test_scores = self.predict_learner(X)[:, 1]
 
         # Compute the prevalence using the mixture model
         prevalence = np.clip(self._compute_prevalence(test_scores), 0, 1)
@@ -256,9 +265,8 @@ class DyS(MixtureModel):
     {0: 0.37719298245614036, 1: 0.6228070175438597}
     """
 
-    def __init__(self, learner: BaseEstimator, measure: str = "topsoe", bins_size: np.ndarray = None):
+    def __init__(self, learner: BaseEstimator=None, measure: str = "topsoe", bins_size: np.ndarray = None):
         assert measure in ["hellinger", "topsoe", "probsymm"], "Invalid measure."
-        assert isinstance(learner, BaseEstimator), "Learner must be a valid estimator."
         super().__init__(learner)
 
         # Set up bins_size
@@ -305,7 +313,7 @@ class DyS(MixtureModel):
         distance : float
             The minimum distance value.
         """
-        test_scores = self.learner.predict_proba(X_test)
+        test_scores = self.predict_learner(X_test)
         prevs = self.GetMinDistancesDyS(test_scores)
 
         size = len(prevs)
@@ -455,9 +463,8 @@ class DySsyn(MixtureModel):
     """
 
     
-    def __init__(self, learner:BaseEstimator, measure:str="topsoe", merge_factor:np.ndarray=None, bins_size:np.ndarray=None, alpha_train:float=0.5, n:int=None):
+    def __init__(self, learner:BaseEstimator=None, measure:str="topsoe", merge_factor:np.ndarray=None, bins_size:np.ndarray=None, alpha_train:float=0.5, n:int=None):
         assert measure in ["hellinger", "topsoe", "probsymm"], "measure not valid"
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
         super().__init__(learner)
         
         # Set up bins_size
@@ -494,8 +501,7 @@ class DySsyn(MixtureModel):
         self : DySsyn
             The fitted DySsyn instance.
         """
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
+        self.fit_learner(X, y)
 
         self.alpha_train = list(get_real_prev(y).values())[1]
 
@@ -538,7 +544,7 @@ class DySsyn(MixtureModel):
         distance : float
             Minimum distance value for the test data.
         """
-        test_scores = self.learner.predict_proba(X_test)
+        test_scores = self.predict_learner(X_test)
 
         distances = self.GetMinDistancesDySsyn(test_scores)
 
@@ -679,8 +685,7 @@ class HDy(MixtureModel):
     {0: 0.37719298245614036, 1: 0.6228070175438597}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "Learner must be a valid estimator."
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
     def _compute_prevalence(self, test_scores: np.ndarray) -> float:
@@ -717,7 +722,7 @@ class HDy(MixtureModel):
         distance : float
             The minimum distance value.
         """
-        test_scores = self.learner.predict_proba(X_test)
+        test_scores = self.predict_learner(X_test)
         _, distances = self.GetMinDistancesHDy(test_scores)
 
         size = len(distances)
@@ -833,8 +838,7 @@ class SMM(MixtureModel):
     {0: 0.37719298245614036, 1: 0.6228070175438597}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "Learner must be a valid estimator."
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
     def _compute_prevalence(self, test_scores: np.ndarray) -> float:
@@ -909,8 +913,7 @@ class SORD(MixtureModel):
     {0: 0.37719298245614036, 1: 0.6228070175438597}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "Learner must be a valid estimator."
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
         self.best_distance_index = None  # Stores the index of the best alpha value

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify/methods/threshold_optimization.py

@@ -4,6 +4,7 @@ from sklearn.base import BaseEstimator
 
 from ..base import AggregativeQuantifier
 from ..utils.method import adjust_threshold, get_scores
+import mlquantify as mq
 
 
 
@@ -67,13 +68,28 @@ class ThresholdOptimization(AggregativeQuantifier):
     >>> y_pred = mtm.predict(X_test)
     """
 
-    def __init__(self, learner: BaseEstimator):
+    def __init__(self, learner: BaseEstimator=None):
         self.learner = learner
         self.threshold = None
         self.cc_output = None
         self.tpr = None
         self.fpr = None
     
+    @property
+    def is_probabilistic(self) -> bool:
+        """
+        Returns whether the method is probabilistic.
+
+        This method is used to determine whether the quantification method is probabilistic, 
+        meaning it uses class-conditional probabilities to estimate class prevalences.
+        
+        Returns
+        -------
+        bool
+            True, indicating that this method is probabilistic.
+        """
+        return True
+    
     @property
     def is_multiclass(self) -> bool:
         """
@@ -106,7 +122,11 @@ class ThresholdOptimization(AggregativeQuantifier):
             The fitted quantifier object with the best threshold, TPR, and FPR.
         """
         # Get predicted labels and probabilities
-        y_labels, probabilities = get_scores(X, y, self.learner, self.cv_folds, self.learner_fitted)
+        if mq.arguments["y_labels"] is not None and mq.arguments["posteriors_train"] is not None:
+            y_labels = mq.arguments["y_labels"]
+            probabilities = mq.arguments["posteriors_train"]
+        else:
+            y_labels, probabilities = get_scores(X, y, self.learner, self.cv_folds, self.learner_fitted)
         
         # Adjust thresholds and compute true and false positive rates
         thresholds, tprs, fprs = adjust_threshold(y_labels, probabilities[:, 1], self.classes)
@@ -131,7 +151,7 @@ class ThresholdOptimization(AggregativeQuantifier):
             An array of predicted prevalences for the classes.
         """
         # Get predicted probabilities for the positive class
-        probabilities = self.learner.predict_proba(X)[:, 1]
+        probabilities = self.predict_learner(X)[:, 1]
         
         # Compute the classification count output based on the threshold
         self.cc_output = len(probabilities[probabilities >= self.threshold]) / len(probabilities)
@@ -231,8 +251,7 @@ class ACC(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator, threshold: float = 0.5):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None, threshold: float = 0.5):
         super().__init__(learner)
         self.threshold = threshold
 
@@ -325,8 +344,7 @@ class MAX(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
     def best_tprfpr(self, thresholds: np.ndarray, tprs: np.ndarray, fprs: np.ndarray) -> tuple:
@@ -428,8 +446,7 @@ class MS(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator, threshold: float = 0.5):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None, threshold: float = 0.5):
         super().__init__(learner)
         self.threshold = threshold
 
@@ -528,8 +545,7 @@ class MS2(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
     def best_tprfpr(self, thresholds: np.ndarray, tprs: np.ndarray, fprs: np.ndarray) -> tuple:
@@ -639,8 +655,7 @@ class PACC(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator, threshold: float = 0.5):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None, threshold: float = 0.5):
         super().__init__(learner)
         self.threshold = threshold
 
@@ -675,7 +690,7 @@ class PACC(ThresholdOptimization):
         prevalences = {}
 
         # Calculate probabilities for the positive class
-        probabilities = self.learner.predict_proba(X)[:, 1]
+        probabilities = self.predict_learner(X)[:, 1]
 
         # Compute the mean score for the positive class
         mean_scores = np.mean(probabilities)
@@ -731,13 +746,6 @@ class PACC(ThresholdOptimization):
     
     
     
-    def best_tprfpr(self, thresholds:np.ndarray, tprs: np.ndarray, fprs: np.ndarray) -> tuple:
-        tpr = tprs[thresholds == self.threshold][0]
-        fpr = fprs[thresholds == self.threshold][0]
-        return (self.threshold, tpr, fpr)
-    
-    
-    
 
 
 
@@ -797,8 +805,7 @@ class T50(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
     def best_tprfpr(self, thresholds: np.ndarray, tprs: np.ndarray, fprs: np.ndarray) -> tuple:
@@ -906,8 +913,7 @@ class X_method(ThresholdOptimization):
     {0: 0.3991228070175439, 1: 0.6008771929824561}
     """
 
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
+    def __init__(self, learner: BaseEstimator=None):
         super().__init__(learner)
 
     def best_tprfpr(self, thresholds: np.ndarray, tprs: np.ndarray, fprs: np.ndarray) -> tuple:

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify/utils/general.py

@@ -256,7 +256,7 @@ def parallel(func, elements, n_jobs: int = 1, *args):
     list
         List of results from running the function on each element.
     """
-    return Parallel(n_jobs=n_jobs)(
+    return Parallel(n_jobs=n_jobs, backend="threading")(
         delayed(func)(e, *args) for e in elements
     )
     

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/mlquantify.egg-info/PKG-INFO

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

{mlquantify-0.0.11.8 → mlquantify-0.0.11.10}/setup.py

@@ -6,7 +6,7 @@ here = pathlib.Path(__file__).parent.resolve()
 
 long_description = (here / 'README.md').read_text(encoding='utf-8')
 
-VERSION = '0.0.11.8'
+VERSION = '0.0.11.10'
 DESCRIPTION = 'Quantification Library'
 
 # Setting up

mlquantify-0.0.11.8/mlquantify/__init__.py

@@ -1,9 +0,0 @@
-"mlquantify, a Python package for quantification"
-
-from . import base
-from . import model_selection
-from . import plots
-from . import classification
-from . import evaluation
-from . import methods
-from . import utils