mlquantify 0.0.11.2__py3-none-any.whl → 0.1.1__py3-none-any.whl

mlquantify/methods/aggregative/cc.py

@@ -1,32 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-from ...base import AggregativeQuantifier
-
-class CC(AggregativeQuantifier):
-    """Classify and Count. The simplest quantification method
-    involves classifying each instance and then counting the 
-    number of instances assigned to each class to estimate 
-    the class prevalence.
-    """
-    
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        self.learner = learner
-    
-    
-    def _fit_method(self, X, y):
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
-        return self
-    
-    
-    def _predict_method(self, X) -> dict:
-        predicted_labels = self.learner.predict(X)
-        
-        # Count occurrences of each class in the predictions
-        class_counts = np.array([np.count_nonzero(predicted_labels == _class) for _class in self.classes])
-        
-        # Calculate the prevalence of each class
-        prevalences = class_counts / len(predicted_labels)
-        
-        return prevalences

mlquantify/methods/aggregative/emq.py

@@ -1,86 +0,0 @@
-import numpy as np
-import pandas as pd
-from sklearn.base import BaseEstimator
-
-from ...base import AggregativeQuantifier
-
-class EMQ(AggregativeQuantifier):
-    """Expectation Maximisation Quantifier. It is a method that
-    ajust the priors and posteriors probabilities of a learner
-    """
-    
-    MAX_ITER = 1000
-    EPSILON = 1e-6
-    
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        self.learner = learner
-        self.priors = None
-    
-    def _fit_method(self, X, y):
-        
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
-        
-        counts = np.array([np.count_nonzero(y == _class) for _class in self.classes])
-        self.priors = counts / len(y)
-        
-        return self
-    
-    def _predict_method(self, X) -> dict:
-        
-        posteriors = self.learner.predict_proba(X)
-        prevalences, _ = self.EM(self.priors, posteriors)
-        
-        return prevalences
-    
-    
-    def predict_proba(self, X, epsilon:float=EPSILON, max_iter:int=MAX_ITER) -> np.ndarray:
-        posteriors = self.learner.predict_proba(X)
-        _, posteriors = self.EM(self.priors, posteriors, epsilon, max_iter)
-        return posteriors
-    
-    
-    @classmethod
-    def EM(cls, priors, posteriors, epsilon=EPSILON, max_iter=MAX_ITER):
-        """Expectaion Maximization function, it iterates several times
-        and At each iteration step, both the a posteriori and the a 
-        priori probabilities are reestimated sequentially for each new 
-        observation and each class. The iterative procedure proceeds 
-        until the convergence of the estimated probabilities.
-
-        Args:
-            priors (array-like): priors probabilites of the train.
-            posteriors (array-like): posteriors probabiblities of the test.
-            epsilon (float): value that helps to indify the convergence.
-            max_iter (int): max number of iterations.
-
-        Returns:
-            the predicted prevalence and the ajusted posteriors.
-        """
-        
-        Px = posteriors
-        prev_prevalence = np.copy(priors)
-        running_estimate = np.copy(prev_prevalence)  # Initialized with the training prevalence
-
-        iteration, converged = 0, False
-        previous_estimate = None
-
-        while not converged and iteration < max_iter:
-            # E-step: ps is P(y|xi)
-            posteriors_unnormalized = (running_estimate / prev_prevalence) * Px
-            posteriors = posteriors_unnormalized / posteriors_unnormalized.sum(axis=1, keepdims=True)
-
-            # M-step:
-            running_estimate = posteriors.mean(axis=0)
-
-            if previous_estimate is not None and np.mean(np.abs(running_estimate - previous_estimate)) < epsilon and iteration > 10:
-                converged = True
-
-            previous_estimate = running_estimate
-            iteration += 1
-
-        if not converged:
-            print('[Warning] The method has reached the maximum number of iterations; it might not have converged')
-
-        return running_estimate, posteriors

mlquantify/methods/aggregative/fm.py

@@ -1,72 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-from scipy.optimize import minimize
-
-from ...base import AggregativeQuantifier
-from ...utils import get_scores
-
-class FM(AggregativeQuantifier):
-    """The Friedman Method. Similar to GPAC, 
-    but instead of averaging the confidence scores
-    from probabilistic classifiers, it uses the proportion
-    of confidence scores that are higher or lower than the
-    expected class frequencies found in the training data.
-    """
-    
-    
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        self.learner = learner
-        self.CM = None
-    
-    def _fit_method(self, X, y):
-        # Get predicted labels and probabilities using cross-validation
-        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)
-        
-        # Initialize the confusion matrix
-        CM = np.zeros((self.n_class, self.n_class))
-        
-        # Calculate the class priors
-        class_counts = np.array([np.count_nonzero(y_labels == _class) for _class in self.classes])
-        self.priors = class_counts / len(y_labels)
-        
-        # Populate the confusion matrix
-        for i, _class in enumerate(self.classes):       
-            indices = np.where(y_labels == _class)[0]
-            CM[:, i] = np.sum(probabilities[indices] > self.priors, axis=0) 
-        
-        # Normalize the confusion matrix by class counts
-        self.CM = CM / class_counts
-        
-        return self
-    
-    def _predict_method(self, X) -> dict:
-        posteriors = self.learner.predict_proba(X)
-        
-        # Calculate the estimated prevalences in the test set
-        prevs_estim = np.sum(posteriors > self.priors, axis=0) / posteriors.shape[0]
-        # Define the objective function for optimization
-        def objective(prevs_pred):
-            return np.linalg.norm(self.CM @ prevs_pred - prevs_estim)
-        
-        # Constraints for the optimization problem
-        constraints = [{'type': 'eq', 'fun': lambda prevs_pred: np.sum(prevs_pred) - 1.0},
-                       {'type': 'ineq', 'fun': lambda prevs_pred: prevs_pred}]
-        
-        # Initial guess for the optimization
-        initial_guess = np.ones(self.CM.shape[1]) / self.CM.shape[1]
-        
-        # Solve the optimization problem
-        result = minimize(objective, initial_guess, constraints=constraints, bounds=[(0, 1)]*self.CM.shape[1])
-        
-        if result.success:
-            prevalences = result.x
-        else:
-            print("Optimization did not converge")
-            prevalences = self.priors
-        
-        return prevalences

mlquantify/methods/aggregative/gac.py

@@ -1,96 +0,0 @@
-import numpy as np
-import pandas as pd
-from sklearn.base import BaseEstimator
-from sklearn.metrics import confusion_matrix
-from sklearn.model_selection import StratifiedKFold
-
-from ...base import AggregativeQuantifier
-
-
-class GAC(AggregativeQuantifier):
-    """Generalized Adjusted Count. It applies a 
-    classifier to build a system of linear equations, 
-    and solve it via constrained least-squares regression.
-    """
-    
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        self.learner = learner
-        self.cond_prob_matrix = None
-    
-    def _fit_method(self, X, y):
-        # Ensure X and y are DataFrames
-        if isinstance(X, np.ndarray):
-            X = pd.DataFrame(X)
-        if isinstance(y, np.ndarray):
-            y = pd.Series(y)
-
-        if self.learner_fitted:
-            y_pred = self.learner.predict(X)
-            y_label = y
-        else:
-            # Cross-validation for generating predictions
-            skf = StratifiedKFold(n_splits=self.cv_folds)
-            y_pred = []
-            y_label = []
-            
-            for train_index, valid_index in skf.split(X, y):
-                
-                train_data = pd.DataFrame(X.iloc[train_index])
-                train_label = y.iloc[train_index]
-                
-                valid_data = pd.DataFrame(X.iloc[valid_index])
-                valid_label = y.iloc[valid_index]
-                
-                self.learner.fit(train_data, train_label)
-                
-                y_pred.extend(self.learner.predict(valid_data))
-                y_label.extend(valid_label)
-        
-        # Compute conditional probability matrix
-        self.cond_prob_matrix = self.get_cond_prob_matrix(self.classes, y, y_pred)
-        
-        return self
-    
-    def _predict_method(self, X) -> dict:
-        # Predict class labels for the test data
-        y_pred = self.learner.predict(X)
-
-        # Distribution of predictions in the test set
-        _, counts = np.unique(y_pred, return_counts=True)
-        predicted_prevalences = counts / counts.sum()
-        
-        # Adjust prevalences based on conditional probability matrix
-        adjusted_prevalences = self.solve_adjustment(self.cond_prob_matrix, predicted_prevalences)
-
-        return adjusted_prevalences
-    
-    @classmethod
-    def get_cond_prob_matrix(cls, classes:list, true_labels:np.ndarray, predictions:np.ndarray) -> np.ndarray:
-        """ Estimate the conditional probability matrix P(yi|yj)"""
-
-        CM = confusion_matrix(true_labels, predictions, labels=classes).T
-        CM = CM.astype(np.float32)
-        class_counts = CM.sum(axis=0)
-        for i, _ in enumerate(classes):
-            if class_counts[i] == 0:
-                CM[i, i] = 1
-            else:
-                CM[:, i] /= class_counts[i]
-        return CM
-    
-    @classmethod
-    def solve_adjustment(cls, cond_prob_matrix, predicted_prevalences):
-        """ Solve the linear system Ax = B with A=cond_prob_matrix and B=predicted_prevalences
-        """
-        
-        #
-        A = cond_prob_matrix
-        B = predicted_prevalences
-        try:
-            adjusted_prevalences = np.linalg.solve(A, B)
-            adjusted_prevalences = np.clip(adjusted_prevalences, 0, 1)
-            adjusted_prevalences /= adjusted_prevalences.sum()
-        except (np.linalg.LinAlgError, ValueError):
-            adjusted_prevalences = predicted_prevalences  # No way to adjust them
-        return adjusted_prevalences

mlquantify/methods/aggregative/gpac.py

@@ -1,87 +0,0 @@
-import numpy as np
-import pandas as pd
-from sklearn.base import BaseEstimator
-from sklearn.model_selection import StratifiedKFold
-
-from .gac import GAC
-from ...base import AggregativeQuantifier
-
-class GPAC(AggregativeQuantifier):
-    """Generalized Probabilistic Adjusted Count. Like 
-    GAC, it also build a system of linear equations, but 
-    utilize the confidence scores from probabilistic 
-    classifiers as in the PAC method.
-    """
-    
-    
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        self.learner = learner
-        self.cond_prob_matrix = None
-    
-    def _fit_method(self, X, y):
-        # Convert X and y to DataFrames if they are numpy arrays
-        if isinstance(X, np.ndarray):
-            X = pd.DataFrame(X)
-        if isinstance(y, np.ndarray):
-            y = pd.DataFrame(y)
-            
-        if self.learner_fitted:
-            # Use existing model to predict
-            predictions = self.learner.predict(X)
-            true_labels = y
-        else:
-            # Perform cross-validation to generate predictions
-            skf = StratifiedKFold(n_splits=self.cv_folds)
-            predictions = []
-            true_labels = []
-            
-            for train_index, valid_index in skf.split(X, y):
-                # Split data into training and validation sets
-                train_data = pd.DataFrame(X.iloc[train_index])
-                train_labels = y.iloc[train_index]
-                
-                valid_data = pd.DataFrame(X.iloc[valid_index])
-                valid_labels = y.iloc[valid_index]
-                
-                # Train the learner
-                self.learner.fit(train_data, train_labels)
-                
-                # Predict and collect results
-                predictions.extend(self.learner.predict(valid_data))
-                true_labels.extend(valid_labels)
-        
-        # Compute conditional probability matrix using GAC
-        self.cond_prob_matrix = GAC.get_cond_prob_matrix(self.classes, true_labels, predictions)
-        
-        return self
-    
-    def _predict_method(self, X) -> dict:
-        # Predict class labels for the test data
-        predictions = self.learner.predict(X)
-
-        # Calculate the distribution of predictions in the test set
-        predicted_prevalences = np.zeros(self.n_class)
-        _, counts = np.unique(predictions, return_counts=True)
-        predicted_prevalences[:len(counts)] = counts
-        predicted_prevalences = predicted_prevalences / predicted_prevalences.sum()
-        
-        # Adjust prevalences based on the conditional probability matrix from GAC
-        adjusted_prevalences = GAC.solve_adjustment(self.cond_prob_matrix, predicted_prevalences)
-
-        # Map class labels to their corresponding prevalences
-        return adjusted_prevalences
-    
-    @classmethod
-    def get_cond_prob_matrix(cls, classes:list, true_labels:np.ndarray, predictions:np.ndarray) -> np.ndarray:
-        """Estimate the matrix where entry (i,j) is the estimate of P(yi|yj)"""
-        
-        n_classes = len(classes)
-        cond_prob_matrix = np.eye(n_classes)
-        
-        for i, class_ in enumerate(classes):
-            class_indices = true_labels == class_
-            if class_indices.any():
-                cond_prob_matrix[i] = predictions[class_indices].mean(axis=0)
-        
-        return cond_prob_matrix.T

mlquantify/methods/aggregative/mixtureModels/_MixtureModel.py

@@ -1,81 +0,0 @@
-from abc import abstractmethod
-import numpy as np
-from sklearn.base import BaseEstimator
-
-from ....base import AggregativeQuantifier
-from ....utils import probsymm, sqEuclidean, topsoe, hellinger, get_scores
-
-class MixtureModel(AggregativeQuantifier):
-    """Generic Class for the Mixture Models methods, which
-    are based oon the assumption that the cumulative 
-    distribution of the scores assigned to data points in the test
-    is a mixture of the scores in train data
-    """
-    
-    def __init__(self, learner: BaseEstimator):
-        self.learner = learner
-        self.pos_scores = None
-        self.neg_scores = None
-        self.distance = None
-
-    @property
-    def multiclass_method(self) -> bool:
-        return False
-
-    def _fit_method(self, X, y):
-        # Compute scores with cross validation and fit the learner if not already fitted
-        y_label, 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]
-
-        return self
-
-    def _predict_method(self, X) -> dict:
-        prevalences = {}
-
-        # Get the predicted probabilities for the positive class
-        test_scores = self.learner.predict_proba(X)[:, 1]
-
-        # Compute the prevalence using the provided measure
-        prevalence = np.clip(self._compute_prevalence(test_scores), 0, 1)
-
-        # Clip the prevalence to be within the [0, 1] range and compute the complement for the other class
-        prevalences = np.asarray([1- prevalence, prevalence])
-
-        return prevalences
-
-    @abstractmethod
-    def _compute_prevalence(self, test_scores: np.ndarray) -> float:
-        """ Abstract method for computing the prevalence using the test scores """
-        ...
-
-    def get_distance(self, dist_train, dist_test, measure: str) -> float:
-        """Compute the distance between training and test distributions using the specified metric"""
-
-        # Check if any vector is too small or if they have different lengths
-        if np.sum(dist_train) < 1e-20 or np.sum(dist_test) < 1e-20:
-            raise ValueError("One or both vectors are zero (empty)...")
-        if len(dist_train) != len(dist_test):
-            raise ValueError("Arrays need to be of equal size...")
-
-        # Convert distributions to numpy arrays for efficient computation
-        dist_train = np.array(dist_train, dtype=float)
-        dist_test = np.array(dist_test, dtype=float)
-
-        # Avoid division by zero by correcting zero values
-        dist_train[dist_train < 1e-20] = 1e-20
-        dist_test[dist_test < 1e-20] = 1e-20
-
-        # Compute and return the distance based on the selected metric
-        if measure == 'topsoe':
-            return topsoe(dist_train, dist_test)
-        elif measure == 'probsymm':
-            return probsymm(dist_train, dist_test)
-        elif measure == 'hellinger':
-            return hellinger(dist_train, dist_test)
-        elif measure == 'euclidean':
-            return sqEuclidean(dist_train, dist_test)
-        else:
-            return 100  # Default value if an unknown measure is provided

mlquantify/methods/aggregative/mixtureModels/__init__.py

@@ -1,5 +0,0 @@
-from .hdy import HDy
-from .dys import DyS
-from .sord import SORD
-from .smm import SMM
-from .dys_syn import DySsyn

mlquantify/methods/aggregative/mixtureModels/dys.py

@@ -1,55 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-
-from ._MixtureModel import MixtureModel
-from ....utils import getHist, ternary_search
-
-class DyS(MixtureModel):
-    """Distribution y-Similarity framework. Is a 
-    method that generalises the HDy approach by 
-    considering the dissimilarity function DS as 
-    a parameter of the model
-    """
-    
-    def __init__(self, learner:BaseEstimator, measure:str="topsoe", bins_size:np.ndarray=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
-        if not bins_size:
-            bins_size = np.append(np.linspace(2,20,10), 30)
-        if isinstance(bins_size, list):
-            bins_size = np.asarray(bins_size)
-            
-        self.bins_size = bins_size
-        self.measure = measure
-        
-    
-    def _compute_prevalence(self, test_scores:np.ndarray) -> float:    #creating bins from 10 to 110 with step size 10
-        # Compute prevalence by evaluating the distance metric across various bin sizes
-        
-        result = []
- 
-        # Iterate over each bin size
-        for bins in self.bins_size:
-            # Compute histogram densities for positive, negative, and test scores
-            pos_bin_density = getHist(self.pos_scores, bins)
-            neg_bin_density = getHist(self.neg_scores, bins)
-            test_bin_density = getHist(test_scores, bins)
-
-            # Define the function to minimize
-            def f(x):
-                # Combine densities using a mixture of positive and negative densities
-                train_combined_density = (pos_bin_density * x) + (neg_bin_density * (1 - x))
-                # Calculate the distance between combined density and test density
-                return self.get_distance(train_combined_density, test_bin_density, measure=self.measure)
-        
-            # Use ternary search to find the best x that minimizes the distance
-            result.append(ternary_search(0, 1, f))
-                            
-        # Use the median of the results as the final prevalence estimate
-        prevalence = np.median(result)
-            
-        return prevalence
-        

mlquantify/methods/aggregative/mixtureModels/dys_syn.py

@@ -1,89 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-
-from ._MixtureModel import MixtureModel
-from ....utils import getHist, ternary_search, MoSS, get_real_prev
-
-class DySsyn(MixtureModel):
-    """Synthetic Distribution y-Similarity. This method works the
-    same as DyS method, but istead of using the train scores, it 
-    generates them via MoSS (Model for Score Simulation) which 
-    generate a spectrum of score distributions from highly separated
-    scores to fully mixed scores.
-    """
-    
-    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):
-        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
-        if not bins_size:
-            bins_size = np.append(np.linspace(2,20,10), 30)
-        if isinstance(bins_size, list):
-            bins_size = np.asarray(bins_size)
-            
-        if not merge_factor:
-            merge_factor = np.linspace(0.1, 0.4, 10)
-            
-        self.bins_size = bins_size
-        self.merge_factor = merge_factor
-        self.alpha_train = alpha_train
-        self.n = n
-        self.measure = measure
-        self.m = None
-    
-    
-    def _fit_method(self, X, y):
-        if not self.learner_fitted:
-            self.learner.fit(X, y)
-            
-        self.alpha_train = list(get_real_prev(y).values())[1]
-        
-        return self
-    
-    
-    
-    def _compute_prevalence(self, test_scores:np.ndarray) -> float:    #creating bins from 10 to 110 with step size 10
-        # Compute prevalence by evaluating the distance metric across various bin sizes
-        if self.n is None:
-            self.n = len(test_scores)
-            
-        distances = {}
-        
-        # Iterate over each bin size
-        for m in self.merge_factor:
-            pos_scores, neg_scores = MoSS(self.n, self.alpha_train, m)
-            result  = []
-            for bins in self.bins_size:
-                # Compute histogram densities for positive, negative, and test scores
-                pos_bin_density = getHist(pos_scores, bins)
-                neg_bin_density = getHist(neg_scores, bins)
-                test_bin_density = getHist(test_scores, bins)
-
-                # Define the function to minimize
-                def f(x):
-                    # Combine densities using a mixture of positive and negative densities
-                    train_combined_density = (pos_bin_density * x) + (neg_bin_density * (1 - x))
-                    # Calculate the distance between combined density and test density
-                    return self.get_distance(train_combined_density, test_bin_density, measure=self.measure)
-            
-                # Use ternary search to find the best x that minimizes the distance
-                result.append(ternary_search(0, 1, f))
-            prevalence = np.median(result)
-            
-            bins_size = self.bins_size[result == prevalence][0]
-            
-            pos_bin_density = getHist(pos_scores, bins_size)
-            neg_bin_density = getHist(neg_scores, bins_size)
-            test_bin_density = getHist(test_scores, bins_size)
-            
-            train_combined_density = (pos_bin_density * prevalence) + (neg_bin_density * (1 - prevalence))
-            d = self.get_distance(train_combined_density, test_bin_density, measure=self.measure)
-            distances[m] = (d, prevalence)
-        # Use the median of the results as the final prevalence estimate
-        index = min(distances, key=lambda d: distances[d][0])
-        prevalence = distances[index][1]
-            
-        return prevalence
-        

mlquantify/methods/aggregative/mixtureModels/hdy.py

@@ -1,46 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-
-from ._MixtureModel import MixtureModel
-from ....utils import getHist
-
-class HDy(MixtureModel):
-    """Hellinger Distance Minimization. The method
-    is based on computing the hellinger distance of 
-    two distributions, test distribution and the mixture
-    of the positive and negative distribution of the train.
-    """
-
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        super().__init__(learner)
-        
-    def _compute_prevalence(self, test_scores: np.ndarray) -> float:
-        # Define bin sizes and alpha values
-        bin_size = np.arange(10, 110, 11)  # Bins from 10 to 110 with a step size of 10
-        alpha_values = np.round(np.linspace(0, 1, 101), 2)  # Alpha values from 0 to 1, rounded to 2 decimal places
-        
-        best_alphas = []
-
-        for bins in bin_size:
-
-            pos_bin_density = getHist(self.pos_scores, bins)
-            neg_bin_density = getHist(self.neg_scores, bins)
-            test_bin_density = getHist(test_scores, bins)
-            
-            distances = []
-            
-            # Evaluate distance for each alpha value
-            for x in alpha_values:
-                # Combine densities using a mixture of positive and negative densities
-                train_combined_density = (pos_bin_density * x) + (neg_bin_density * (1 - x))
-                # Compute the distance using the Hellinger measure
-                distances.append(self.get_distance(train_combined_density, test_bin_density, measure="hellinger"))
-
-            # Find the alpha value that minimizes the distance
-            best_alphas.append(alpha_values[np.argmin(distances)])
-        
-        # Compute the median of the best alpha values as the final prevalence estimate
-        prevalence = np.median(best_alphas)
-            
-        return prevalence

mlquantify/methods/aggregative/mixtureModels/smm.py

@@ -1,27 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-
-from ._MixtureModel import MixtureModel
-
-class SMM(MixtureModel):
-    """Sample Mean Matching. The method is 
-    a member of the DyS framework that uses 
-    simple means to represent the score 
-    distribution for positive, negative 
-    and unlabelled scores.
-    """
-
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        super().__init__(learner)
-        
-    def _compute_prevalence(self, test_scores: np.ndarray) -> float:
-        mean_pos_score = np.mean(self.pos_scores)
-        mean_neg_score = np.mean(self.neg_scores)
-        mean_test_score = np.mean(test_scores)
-        
-        # Calculate prevalence as the proportion of the positive class
-        # based on the mean test score relative to the mean positive and negative scores
-        prevalence = (mean_test_score - mean_neg_score) / (mean_pos_score - mean_neg_score)
-        
-        return prevalence