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

mlquantify/methods/aggregative/mixtureModels/sord.py

@@ -1,77 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-
-from ._MixtureModel import MixtureModel
-
-class SORD(MixtureModel):
-    """Sample Ordinal Distance. Is a method 
-    that does not rely on distributions, but 
-    estimates the prevalence of the positive 
-    class in a test dataset by calculating and 
-    minimizing a sample ordinal distance measure 
-    between the test scores and known positive 
-    and negative scores.
-    """
-
-    def __init__(self, learner: BaseEstimator):
-        assert isinstance(learner, BaseEstimator), "learner object is not an estimator"
-        super().__init__(learner)
-        
-        self.best_distance_index = None
-        
-    def _compute_prevalence(self, test_scores: np.ndarray) -> float:
-        # Compute alpha values and corresponding distance measures
-        alpha_values, distance_measures = self._calculate_distances(test_scores)
-        
-        # Find the index of the alpha value with the minimum distance measure
-        self.best_distance_index = np.argmin(distance_measures)
-        prevalence = alpha_values[self.best_distance_index]
-        
-        return prevalence
-    
-    
-    def _calculate_distances(self, test_scores: np.ndarray):
-        # Define a range of alpha values from 0 to 1
-        alpha_values = np.linspace(0, 1, 101)
-        
-        # Get the number of positive, negative, and test scores
-        num_pos_scores = len(self.pos_scores)
-        num_neg_scores = len(self.neg_scores)
-        num_test_scores = len(test_scores)
-
-        distance_measures = []
-
-        # Iterate over each alpha value
-        for alpha in alpha_values:
-            # Compute weights for positive, negative, and test scores
-            pos_weight = alpha / num_pos_scores
-            neg_weight = (1 - alpha) / num_neg_scores
-            test_weight = -1 / num_test_scores
-
-            # Create arrays with weights
-            pos_weights = np.full(num_pos_scores, pos_weight)
-            neg_weights = np.full(num_neg_scores, neg_weight)
-            test_weights = np.full(num_test_scores, test_weight)
-
-            # Concatenate all scores and their corresponding weights
-            all_scores = np.concatenate([self.pos_scores, self.neg_scores, test_scores])
-            all_weights = np.concatenate([pos_weights, neg_weights, test_weights])
-
-            # Sort scores and weights based on scores
-            sorted_indices = np.argsort(all_scores)
-            sorted_scores = all_scores[sorted_indices]
-            sorted_weights = all_weights[sorted_indices]
-
-            # Compute the total cost for the current alpha
-            cumulative_weight = sorted_weights[0]
-            total_cost = 0
-
-            for i in range(1, len(sorted_scores)):
-                # Calculate the cost for the segment between sorted scores
-                segment_width = sorted_scores[i] - sorted_scores[i - 1]
-                total_cost += abs(segment_width * cumulative_weight)
-                cumulative_weight += sorted_weights[i]
-
-            distance_measures.append(total_cost)
-
-        return alpha_values, distance_measures

mlquantify/methods/aggregative/pcc.py

@@ -1,33 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-from ...base import AggregativeQuantifier
-
-class PCC(AggregativeQuantifier):
-    """Probabilistic Classify and Count. This method
-    takes the probabilistic predictions and takes the 
-    mean of them for each class.
-    """
-    
-    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:
-        # Initialize a dictionary to store the prevalence for each class
-        prevalences = []
-        
-        # 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]
-        
-            # Compute the average probability (prevalence) for the current class
-            mean_prev = np.mean(class_probabilities)
-            prevalences.append(mean_prev)
-        
-        return np.asarray(prevalences)

mlquantify/methods/aggregative/pwk.py

@@ -1,38 +0,0 @@
-import numpy as np
-from sklearn.base import BaseEstimator
-from collections import defaultdict
-
-from ...base import AggregativeQuantifier
-
-class PWK(AggregativeQuantifier):
-    """ Nearest-Neighbor based Quantification. This method 
-    is based on nearest-neighbor based classification to the
-    setting of quantification. In this k-NN approach, it applies
-    a weighting scheme which applies less weight on neighbors 
-    from the majority class.
-    Must be used with PWKCLF to work as expected.
-    """
-    
-    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:
-        # Predict class labels for the given data
-        predicted_labels = self.learner.predict(X)
-        
-        # Compute the distribution of predicted labels
-        unique_labels, label_counts = np.unique(predicted_labels, return_counts=True)
-        
-        # Calculate the prevalence for each class
-        class_prevalences = label_counts / label_counts.sum()
-        
-        # Map each class label to its prevalence
-        prevalences  = {label: prevalence for label, prevalence in zip(unique_labels, class_prevalences)}
-        
-        return prevalences

mlquantify/methods/meta/__init__.py

@@ -1 +0,0 @@
-from .ensemble import Ensemble

mlquantify/methods/meta/ensemble.py

@@ -1,236 +0,0 @@
-import numpy as np
-import pandas as pd
-from copy import deepcopy
-from tqdm import tqdm
-from sklearn.linear_model import LogisticRegression
-from sklearn.model_selection import GridSearchCV, cross_val_predict
-from ...evaluation import measures
-from ...base import Quantifier
-from ...utils import make_prevs, getHist, normalize_prevalence, parallel, hellinger, generate_artificial_indexes
-
-class Ensemble(Quantifier):
-    SELECTION_METRICS = {'all', 'ptr', 'ds'}
-
-    """Ensemble method, based on the articles:
-    Pérez-Gállego, P., Quevedo, J. R., & del Coz, J. J. (2017).
-    Using ensembles for problems with characterizable changes in data distribution: A case study on quantification.
-    Information Fusion, 34, 87-100.
-    and
-    Pérez-Gállego, P., Castano, A., Quevedo, J. R., & del Coz, J. J. (2019). 
-    Dynamic ensemble selection for quantification tasks. 
-    Information Fusion, 45, 1-15.
-    
-        This approach of Ensemble is made of taking multiple
-    samples varying class proportions on each, and for the 
-    predictions, it takes the k models which as the minimum
-    seletion metric, which are:
-     - all -> return all the predictions
-     - ptr -> computes the selected error measure
-     - ds -> computes the hellinger distance of the train and test
-     distributions for each model
-    
-    """
-
-    def __init__(self,
-                 quantifier:Quantifier,
-                 size:int=50,
-                 min_prop:float=0.1,
-                 selection_metric:str='all',
-                 p_metric:float=0.25,
-                 return_type:str="mean",
-                 max_sample_size:int=None,
-                 max_trials:int=100, 
-                 n_jobs:int=1,
-                 verbose:bool=False):
-        
-        assert selection_metric in Ensemble.SELECTION_METRICS, \
-            f'unknown selection_metric={selection_metric}; valid are {Ensemble.SELECTION_METRICS}'
-        assert max_sample_size is None or max_sample_size > 0, \
-            'wrong value for max_sample_size; set it to a positive number or None'
-            
-        self.base_quantifier = quantifier
-        self.size = size
-        self.min_prop = min_prop
-        self.p_metric = p_metric
-        self.selection_metric = selection_metric
-        self.return_type = return_type
-        self.n_jobs = n_jobs
-        self.proba_generator = None
-        self.verbose = verbose
-        self.max_sample_size = max_sample_size
-        self.max_trials = max_trials
-
-    def sout(self, msg):
-        if self.verbose:
-            print('[Ensemble]' + msg)
-
-    def fit(self, X, y):
-        self.sout('Fit')
-        
-        self.classes = np.unique(y)
-        
-        if self.selection_metric == 'ds' and not self.binary_data:
-            raise ValueError(f'ds selection_metric is only defined for binary quantification, but this dataset is not binary')
-        # randomly chooses the prevalences for each member of the ensemble (preventing classes with less than
-        # min_pos positive examples)
-        sample_size = len(y) if self.max_sample_size is None else min(self.max_sample_size, len(y))
-        prevs = [_draw_simplex(ndim=self.n_class, min_val=self.min_prop, max_trials=self.max_trials) for _ in range(self.size)]
-
-
-        posteriors = None
-        if self.selection_metric == 'ds':
-            # precompute the training posterior probabilities
-            posteriors, self.proba_generator = self.ds_get_posteriors(X, y)
-
-
-        args = (
-            (X, y, self.base_quantifier, prev, posteriors, self.verbose, sample_size)
-            for prev in prevs
-        )
-        
-        self.ensemble = parallel(
-            _delayed_new_sample,
-            tqdm(args, desc='fitting ensemble', total=self.size) if self.verbose else args,
-            n_jobs=self.n_jobs)
-
-        self.sout('Fit [Done]')
-        return self
-
-    def predict(self, X):
-        self.sout('Predict')
-        
-        args = ((Qi, X) for Qi in self.ensemble)
-        
-        prevalences = np.asarray(
-            parallel(_delayed_predict, 
-                     tqdm(args, desc="Predicting Ensemble", total=len(self.ensemble)) if self.verbose else args, 
-                     n_jobs=self.n_jobs)
-        )
-
-        prevalences = pd.DataFrame(prevalences).to_numpy()
-        
-        self.p_metric = int(len(prevalences) * self.p_metric)
-
-        if self.selection_metric == 'ptr':
-            prevalences = self.ptr_selection_metric(prevalences)
-        elif self.selection_metric == 'ds':
-            prevalences = self.ds_selection_metric(prevalences, X)
-            
-        
-        if self.return_type == "median":   
-            prevalences = np.median(prevalences, axis=0)
-        else:      
-            prevalences = np.mean(prevalences, axis=0)
-            
-        
-        self.sout('Predict [Done]')
-        return normalize_prevalence(prevalences, self.classes)
-
-
-    def ptr_selection_metric(self, prevalences):
-        """
-        Selects the prevalences made by models that have been trained on samples with a prevalence that is most similar
-        to a first approximation of the test prevalence as made by all models in the ensemble.
-        """
-        test_prev_estim = prevalences.mean(axis=0)
-        tr_prevs = [m[1] for m in self.ensemble]
-        ptr_differences = [measures.mean_squared_error(test_prev_estim, ptr_i) for ptr_i in tr_prevs]
-        order = np.argsort(ptr_differences)
-        return _select_k(prevalences, order, k=self.p_metric)
-
-    def ds_get_posteriors(self, X, y):
-        """
-        In the original article, this procedure is not described in a sufficient level of detail. The paper only says
-        that the distribution of posterior probabilities from training and test examples is compared by means of the
-        Hellinger Distance. However, how these posterior probabilities are generated is not specified. In the article,
-        a Logistic Regressor (LR) is used as the classifier device and that could be used for this purpose. However, in
-        general, a Quantifier is not necessarily an instance of Aggreggative Probabilistic Quantifiers, and so, that the
-        quantifier builds on top of a probabilistic classifier cannot be given for granted. Additionally, it would not
-        be correct to generate the posterior probabilities for training documents that have concurred in training the
-        classifier that generates them.
-        This function thus generates the posterior probabilities for all training documents in a cross-validation way,
-        using a LR with hyperparameters that have previously been optimized via grid search in 5FCV.
-        :return P,f, where P is a ndarray containing the posterior probabilities of the training data, generated via
-        cross-validation and using an optimized LR, and the function to be used in order to generate posterior
-        probabilities for test X.
-        """
-        lr_base = LogisticRegression(class_weight='balanced', max_iter=1000)
-
-        optim = GridSearchCV(
-            lr_base, param_grid={'C': np.logspace(-4, 4, 9)}, cv=5, n_jobs=self.n_jobs, refit=True
-        ).fit(X, y)
-
-        posteriors = cross_val_predict(
-            optim.best_estimator_, X, y, cv=5, n_jobs=self.n_jobs, method='predict_proba'
-        )
-        posteriors_generator = optim.best_estimator_.predict_proba
-
-        return posteriors, posteriors_generator
-
-
-    def ds_selection_metric(self, prevalences, test):
-        test_posteriors = self.proba_generator(test)
-        test_distribution = getHist(test_posteriors, 8)
-        tr_distributions = [m[2] for m in self.ensemble]
-        dist = [hellinger(tr_dist_i, test_distribution) for tr_dist_i in tr_distributions]
-        order = np.argsort(dist)
-        return _select_k(prevalences, order, k=self.p_metric)
-
-def _select_k(elements, order, k):
-    elements_k = [elements[idx] for idx in order[:k]]
-    if elements_k:
-        return elements_k
-    print(f"Unable to take {k} for elements with size {len(elements)}")
-    return elements
-    
-
-
-def _delayed_new_sample(args):
-    X, y, base_quantifier, prev, posteriors, verbose, sample_size = args
-    if verbose:
-        print(f'\tfit-start for prev {str(np.round(prev, 3))}, sample_size={sample_size}')
-    model = deepcopy(base_quantifier)
-
-    sample_index = generate_artificial_indexes(y, prev, sample_size, np.unique(y))
-    X_sample = np.take(X, sample_index, axis=0)
-    y_sample = np.take(y, sample_index, axis=0)
-    #print(X_sample)
-
-    model.fit(X_sample, y_sample)
-
-    tr_prevalence = prev
-    tr_distribution = getHist(posteriors[sample_index], 8) if (posteriors is not None) else None
-    if verbose:
-        print(f'\t \\--fit-ended for prev {str(np.round(prev, 3))}')
-    return (model, tr_prevalence, tr_distribution, X, y)
-
-
-def _delayed_predict(args):
-    quantifier, X = args
-    #print(np.asarray(list(quantifier[0].predict(X).values())))
-    return list(quantifier[0].predict(X).values())
-
-
-def _draw_simplex(ndim, min_val, max_trials=100):
-    """
-    returns a uniform sampling from the ndim-dimensional simplex but guarantees that all dimensions
-    are >= min_class_prev (for min_val>0, this makes the sampling not truly uniform)
-    :param ndim: number of dimensions of the simplex
-    :param min_val: minimum class prevalence allowed. If less than 1/ndim a ValueError will be throw since
-    there is no possible solution.
-    :return: a sample from the ndim-dimensional simplex that is uniform in S(ndim)-R where S(ndim) is the simplex
-    and R is the simplex subset containing dimensions lower than min_val
-    """
-    if min_val >= 1 / ndim:
-        raise ValueError(f'no sample can be draw from the {ndim}-dimensional simplex so that '
-                         f'all its values are >={min_val} (try with a larger value for min_pos)')
-    trials = 0
-    while True:
-        u = make_prevs(ndim)
-        if all(u >= min_val):
-            return u
-        trials += 1
-        if trials >= max_trials:
-            raise ValueError(f'it looks like finding a random simplex with all its dimensions being'
-                             f'>= {min_val} is unlikely (it failed after {max_trials} trials)')
-            

mlquantify/methods/non_aggregative/__init__.py

@@ -1 +0,0 @@
-from .hdx import HDx

mlquantify/methods/non_aggregative/hdx.py

@@ -1,71 +0,0 @@
-import pandas as pd
-import numpy as np
-
-from ...base import NonAggregativeQuantifier
-from ...utils import getHist, hellinger
-
-class HDx(NonAggregativeQuantifier):
-    """Hellinger Distance Minimization. The method is similar 
-    to the HDy method, but istead of computing the hellinger 
-    distance of the scores (generated via classifier), HDx 
-    computes the distance of each one of the features of the 
-    dataset
-    """
-
-    def __init__(self, bins_size:np.ndarray=None):
-        if not bins_size:
-            bins_size = np.append(np.linspace(2,20,10), 30)
-        
-        self.bins_size = bins_size
-        self.neg_features = None
-        self.pos_features = None
-        
-        
-    def _fit_method(self, X, y):
-        
-        
-        self.pos_features = X[y == self.classes[1]]
-        self.neg_features = X[y == self.classes[0]]
-        
-        
-        if not isinstance(X, np.ndarray):
-            self.pos_features = self.pos_features.to_numpy()
-        if not isinstance(y, np.ndarray):
-            self.neg_features = self.neg_features.to_numpy()
-        
-        return self
-    
-    def _predict_method(self, X) -> dict:
-        
-        if not isinstance(X, np.ndarray):
-            X = X.to_numpy()
-    
-        alpha_values = np.round(np.linspace(0, 1, 101), 2)
-        
-        best_distances = {}
-        
-        for x in alpha_values: 
-            
-            distances = []
-            
-            for i in range(X.shape[1]):
-                for bins in self.bins_size:
-                    
-                    dist_feature_pos = getHist(self.pos_features[:, i], bins)
-                    dist_feature_neg = getHist(self.neg_features[:, i], bins)
-                    dist_feature_test = getHist(X[:, i], bins)
-    
-                    # Combine densities using a mixture of positive and negative densities
-                    train_combined_density = (dist_feature_pos * x) + (dist_feature_neg * (1 - x))
-                    # Compute the distance using the Hellinger measure
-                    distances.append(hellinger(train_combined_density, dist_feature_test))
-
-            best_distances[x] = np.mean(distances)
-            
-        prevalence = min(best_distances, key=best_distances.get)
-        
-        return np.asarray([1- prevalence, prevalence])
-            
-            
-                
-    

mlquantify/plots/__init__.py

@@ -1,2 +0,0 @@
-from .protocol_plot import protocol_boxplot, protocol_lineplot
-from .distribution_plot import class_distribution_plot

mlquantify/plots/distribution_plot.py

@@ -1,109 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from pathlib import Path
-from typing import List, Optional, Dict, Any, Union
-
-plt.rcParams.update({
-    'axes.facecolor': "#F8F8F8",
-    'figure.facecolor': "#F8F8F8",
-    'font.family': 'sans-serif',
-    'font.sans-serif': 'Arial',
-    'font.size': 12,
-    'font.weight': 'light',
-    'axes.labelsize': 14,
-    'axes.labelweight': 'light',
-    'axes.titlesize': 16,
-    'axes.titleweight': 'normal',
-    'boxplot.boxprops.linewidth': 0.3,
-    'boxplot.whiskerprops.linewidth': 0.3,
-    'boxplot.capprops.linewidth': 0.3,
-    'boxplot.medianprops.linewidth': 0.6,
-    'boxplot.flierprops.linewidth': 0.3,
-    'boxplot.flierprops.markersize': 0.9,
-    'boxplot.medianprops.color': 'black',
-    'figure.subplot.bottom': 0.2,
-    'axes.grid': True,
-    'grid.color': 'black',
-    'grid.alpha': 0.1,
-    'grid.linewidth': 0.5,
-    'grid.linestyle': '--'
-})
-
-
-
-
-COLORS = [
-    '#FFAB91', '#FFE082', '#A5D6A7', '#4DD0E1', '#FF6F61', '#FF8C94', '#D4A5A5',
-    '#FF677D', '#B9FBC0', '#C2C2F0', '#E3F9A6', '#E2A8F7', '#F7B7A3', '#F7C6C7',
-    '#8D9BFC', '#B4E6FF', '#FF8A65', '#FFC3A0', '#FFCCBC', '#F8BBD0', '#FF9AA2',
-    '#FFB3B3', '#FFDDC1', '#FFE0B2', '#E2A8F7', '#F7C6C7', '#E57373', '#BA68C8',
-    '#4FC3F7', '#FFB3B3', '#FF6F61'
-]
-
-def class_distribution_plot(values: Union[List, np.ndarray],
-                            labels: Union[List, np.ndarray],
-                            bins: int = 30,
-                            title: Optional[str] = None,
-                            legend: bool = True,
-                            save_path: Optional[str] = None,
-                            plot_params: Optional[Dict[str, Any]] = None):
-    
-    """Plot overlaid histograms of class distributions.
-
-    This function creates a plot with overlaid histograms, each representing the distribution
-    of a different class or category. Custom colors, titles, legends, and other plot parameters 
-    can be applied to enhance visualization.
-
-    Args:
-        values (Union[List, np.ndarray]): 
-            A list of arrays or a single array containing values for specific classes or categories.
-        labels (Union[List, np.ndarray]): 
-            A list or an array of labels corresponding to each value set in `values`. 
-            Must be the same length as `values`.
-        bins (int, optional): 
-            Number of bins to use in the histograms. Default is 30.
-        title (Optional[str], optional): 
-            Title of the plot. If not provided, no title will be displayed.
-        legend (bool, optional): 
-            Whether to display a legend. Default is True.
-        save_path (Optional[str], optional): 
-            File path to save the plot image. If not provided, the plot will not be saved.
-        plot_params (Optional[Dict[str, Any]], optional): 
-            Dictionary of custom plotting parameters to apply. Default is None.
-
-    Raises:
-        AssertionError: 
-            If the number of labels does not match the number of value sets.
-
-    """
-
-
-    # Apply custom plotting parameters if provided
-    if plot_params:
-        plt.rcParams.update(plot_params)
-
-    # Ensure the number of labels matches the number of value sets
-    assert len(values) == len(labels), "The number of value sets must match the number of labels."
-
-    # Create the overlaid histogram
-    for i, (value_set, label) in enumerate(zip(values, labels)):
-        plt.hist(value_set, bins=bins, color=COLORS[i % len(COLORS)], edgecolor='black', alpha=0.5, label=label)
-
-    # Add title to the plot if provided
-    if title:
-        plt.title(title)
-
-    # Add legend to the plot if enabled
-    if legend:
-        plt.legend(loc='upper right')
-
-    # Set axis labels
-    plt.xlabel('Values')
-    plt.ylabel('Frequency')
-
-    # Save the figure if a path is specified
-    if save_path:
-        plt.savefig(save_path, bbox_inches='tight')
-
-    # Show the plot
-    plt.show()