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

mlquantify/plots/protocol_plot.py

@@ -1,193 +0,0 @@
-import matplotlib.pyplot as plt
-import matplotlib.colors as mcolors
-import matplotlib.patches as mpatches
-import pandas as pd
-from typing import List, Optional, Dict, Any, Union
-from pathlib import Path
-
-plt.rcParams.update({
-    'lines.markersize': 6,
-    '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 and markers
-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'
-]
-
-MARKERS = ["o", "s", "^", "D", "p", "*", "+", "x", "H", "1", "2", "3", "4", "|", "_"]
-
-def adjust_color_saturation(color: str, saturation_factor: float = 5) -> str:
-    """
-    Adjusts the saturation of a given color.
-    
-    Parameters:
-    - color (str): The original color in hexadecimal format.
-    - saturation_factor (float): The factor by which to adjust the saturation. 
-                                 Values > 1 will increase saturation, 
-                                 values < 1 will decrease it. Default is 1.5.
-    
-    Returns:
-    - str: The color with adjusted saturation in hexadecimal format.
-    """
-    # Convert color to HSV (Hue, Saturation, Value)
-    h, s, v = mcolors.rgb_to_hsv(mcolors.to_rgb(color))
-    
-    # Adjust saturation
-    s = min(1, s * saturation_factor)
-    
-    # Convert back to RGB and then to hex
-    return mcolors.to_hex(mcolors.hsv_to_rgb((h, s, v)))
-
-
-
-def protocol_boxplot(
-    table_protocol: pd.DataFrame,
-    x: str,
-    y: str,
-    methods: Optional[List[str]] = None,
-    title: Optional[str] = None,
-    legend: bool = True,
-    save_path: Optional[str] = None,
-    order: Optional[str] = None,
-    plot_params: Optional[Dict[str, Any]] = None):
-    """
-    Plots a boxplot based on the provided DataFrame and selected methods.
-    """
-    # Handle plot_params
-    plot_params = plot_params or {}
-    figsize = plot_params.pop('figsize', (10, 6))  # Default figsize if not provided
-    
-    # Prepare data
-    table = table_protocol.drop(["PRED_PREVS", "REAL_PREVS"], axis=1).copy()
-    methods = methods or table['QUANTIFIER'].unique()
-    table = table[table['QUANTIFIER'].isin(methods)]
-
-    # Order methods by ranking if specified
-    if order == 'rank':
-        methods = table.groupby('QUANTIFIER')[y].median().sort_values().index.tolist()
-
-    # Create plot with custom figsize
-    fig, ax = plt.subplots(figsize=figsize)
-    ax.grid(False)
-    
-    box = ax.boxplot([table[table['QUANTIFIER'] == method][y] for method in methods],
-                     patch_artist=True, widths=0.8, labels=methods, **plot_params)
-
-    # Apply colors
-    for patch, color in zip(box['boxes'], COLORS[:len(methods)]):
-        patch.set_facecolor(color)
-
-    # Add legend
-    if legend:
-        handles = [mpatches.Patch(color=COLORS[i], label=method) for i, method in enumerate(methods)]
-        ax.legend(handles=handles, title="Quantifiers", loc='upper left', bbox_to_anchor=(1, 1), fontsize=10, title_fontsize='11')
-
-    # Customize plot
-    ax.set_xticklabels(methods, rotation=45, fontstyle='italic')
-    ax.set_xlabel(x.capitalize())
-    ax.set_ylabel(f"{y.capitalize()}")
-    if title:
-        ax.set_title(title)
-
-    # Adjust layout and save plot
-    plt.tight_layout(rect=[0, 0, 0.9, 1])
-    if save_path:
-        plt.savefig(save_path, bbox_inches='tight')
-    plt.show()
-
-
-
-
-
-
-
-def protocol_lineplot(
-    table_protocol: pd.DataFrame,
-    methods: Union[List[str], str, None],
-    x: str,
-    y: str,
-    title: Optional[str] = None,
-    legend: bool = True,
-    save_path: Optional[str] = None,
-    group_by: str = "mean",
-    pos_alpha: int = 1,
-    plot_params: Optional[Dict[str, Any]] = None):
-    """
-    Plots a line plot based on the provided DataFrame of the protocol and selected methods.
-    """
-    # Handle plot_params
-    plot_params = plot_params or {}
-    figsize = plot_params.pop('figsize', (10, 6))  # Default figsize if not provided
-
-    # Filter data
-    methods = methods or table_protocol['QUANTIFIER'].unique()
-    table_protocol = table_protocol[table_protocol['QUANTIFIER'].isin(methods)]
-    
-    if x == "ALPHA":
-        real = table_protocol["REAL_PREVS"].apply(lambda x: x[pos_alpha])
-        table = table_protocol.drop(["PRED_PREVS", "REAL_PREVS"], axis=1).copy()
-        table["ALPHA"] = real
-    else:
-        table = table_protocol.drop(["PRED_PREVS", "REAL_PREVS"], axis=1).copy()
-    
-    # Aggregate data
-    if group_by:
-        table = table.groupby(['QUANTIFIER', x])[y].agg(group_by).reset_index()
-
-    # Create plot with custom figsize
-    fig, ax = plt.subplots(figsize=figsize)
-    for i, (method, marker) in enumerate(zip(methods, MARKERS[:len(methods)+1])):
-        method_data = table[table['QUANTIFIER'] == method]
-        y_data = real if y == "ALPHA" else method_data[y]
-        color = adjust_color_saturation(COLORS[i % len(COLORS)])  # Aumenta a saturação das cores
-        ax.plot(method_data[x], 
-                y_data, color=color, 
-                marker=marker, 
-                label=method,
-                alpha=1.0, 
-                **plot_params)
-
-    # Add legend
-    if legend:
-        ax.legend(title="Quantifiers", loc='upper left', bbox_to_anchor=(1, 1), fontsize=10, title_fontsize='11')
-
-    # Customize plot
-    ax.set_xlabel(x.capitalize())
-    ax.set_ylabel(y.capitalize())
-    if title:
-        ax.set_title(title)
-
-    # Adjust layout and save plot
-    plt.tight_layout(rect=[0, 0, 0.9, 1])
-    if save_path:
-        plt.savefig(save_path, bbox_inches='tight')
-    plt.show()
-
-    

mlquantify/utils/general_purposes/__init__.py

@@ -1,8 +0,0 @@
-from .normalize import normalize_prevalence
-from .parallel import parallel
-from .get_real_prev import get_real_prev
-from .make_prevs import make_prevs
-from .generate_artificial_indexes import generate_artificial_indexes
-from .round_protocol_df import round_protocol_df
-from .convert_col_to_array import convert_columns_to_arrays
-from .load_quantifier import load_quantifier

mlquantify/utils/general_purposes/convert_col_to_array.py

@@ -1,13 +0,0 @@
-import numpy as np
-
-def convert_columns_to_arrays(df, columns:list = ['PRED_PREVS', 'REAL_PREVS']):
-    """Converts the specified columns from string of arrays to numpy arrays
-
-    Args:
-        df (array-like): the dataframe from which to change convert the coluns
-        columns (list, optional): the coluns with string of arrays, default is the options for
-        the protocol dataframes
-    """
-    for col in columns:
-        df[col] = df[col].apply(lambda x: np.fromstring(x.strip('[]'), sep=' ') if isinstance(x, str) else x)
-    return df

mlquantify/utils/general_purposes/generate_artificial_indexes.py

@@ -1,29 +0,0 @@
-import numpy as np
-
-def generate_artificial_indexes(y, prevalence: list, sample_size:int, classes:list):        
-    # Ensure the sum of prevalences is 1
-    assert np.isclose(sum(prevalence), 1), "The sum of prevalences must be 1"
-    # Ensure the number of prevalences matches the number of classes
-
-    sampled_indexes = []
-    total_sampled = 0
-
-    for i, class_ in enumerate(classes):
-
-        if i == len(classes) - 1:
-            num_samples = sample_size - total_sampled
-        else:
-            num_samples = int(sample_size * prevalence[i])
-        
-        # Get the indexes of the current class
-        class_indexes = np.where(y == class_)[0]
-
-        # Sample the indexes for the current class
-        sampled_class_indexes = np.random.choice(class_indexes, size=num_samples, replace=True)
-        
-        sampled_indexes.extend(sampled_class_indexes)
-        total_sampled += num_samples
-
-    np.random.shuffle(sampled_indexes)  # Shuffle after collecting all indexes
-        
-    return sampled_indexes

mlquantify/utils/general_purposes/get_real_prev.py

@@ -1,9 +0,0 @@
-import numpy as np
-import pandas as pd
-
-def get_real_prev(y) -> dict:
-    if isinstance(y, np.ndarray):
-        y = pd.Series(y)
-    real_prevs = y.value_counts(normalize=True).to_dict()
-    real_prevs = dict(sorted(real_prevs.items()))
-    return real_prevs

mlquantify/utils/general_purposes/load_quantifier.py

@@ -1,4 +0,0 @@
-import joblib
-
-def load_quantifier(path:str):
-    return joblib.load(path)

mlquantify/utils/general_purposes/make_prevs.py

@@ -1,23 +0,0 @@
-import numpy as np
-
-def make_prevs(ndim:int) -> list:
-    """
-    Generate a list of n_dim values uniformly distributed between 0 and 1 that sum exactly to 1.
-    
-    Args:
-    n_dim (int): Number of values in the list.
-    
-    Returns:
-    list: List of n_dim values that sum to 1.
-    """
-    # Generate n_dim-1 random u_dist uniformly distributed between 0 and 1
-    u_dist = np.random.uniform(0, 1, ndim - 1)
-    # Add 0 and 1 to the u_dist
-    u_dist = np.append(u_dist, [0, 1])
-    # Sort the u_dist
-    u_dist.sort()
-    # Calculate the differences between consecutive u_dist
-    prevs = np.diff(u_dist)
-
-    return prevs
-        

mlquantify/utils/general_purposes/normalize.py

@@ -1,20 +0,0 @@
-import numpy as np
-from collections import defaultdict
-
-def normalize_prevalence(prevalences: np.ndarray, classes:list):
-    
-    if isinstance(prevalences, dict):
-        summ = sum(prevalences.values())
-        prevalences = {int(_class):float(value/summ) for _class, value in prevalences.items()}
-        return prevalences
-    
-    summ = np.sum(prevalences, axis=-1, keepdims=True)
-    prevalences = np.true_divide(prevalences, sum(prevalences), where=summ>0)
-    prevalences = {int(_class):float(prev) for _class, prev in zip(classes, prevalences)}
-    prevalences = defaultdict(lambda: 0, prevalences)
-    
-    # Ensure all classes are present in the result
-    for cls in classes:
-        prevalences[cls] = prevalences[cls]
-    
-    return dict(prevalences)

mlquantify/utils/general_purposes/parallel.py

@@ -1,10 +0,0 @@
-from joblib import Parallel, delayed
-import numpy as np
-
-
-def parallel(func, elements, n_jobs: int = 1, *args):
-    return Parallel(n_jobs=n_jobs)(
-        delayed(func)(e, *args) for e in elements
-    )
-
-    

mlquantify/utils/general_purposes/round_protocol_df.py

@@ -1,14 +0,0 @@
-import numpy as np
-import pandas as pd
-
-
-def round_protocol_df(dataframe: pd.DataFrame, frac: int = 3):
-    def round_column(col):
-        if col.name in ['PRED_PREVS', 'REAL_PREVS']:
-            return col.apply(lambda x: np.round(x, frac) if isinstance(x, (np.ndarray, float, int)) else x)
-        elif np.issubdtype(col.dtype, np.number):
-            return col.round(frac)
-        else:
-            return col
-    
-    return dataframe.apply(round_column)

mlquantify/utils/method_purposes/__init__.py

@@ -1,6 +0,0 @@
-from .getHist import getHist
-from .distances import sqEuclidean, probsymm, hellinger, topsoe
-from .ternary_search import ternary_search
-from .tprfpr import compute_table, compute_tpr, compute_fpr, adjust_threshold
-from .get_scores import get_scores
-from .moss import MoSS

mlquantify/utils/method_purposes/distances.py

@@ -1,21 +0,0 @@
-import numpy as np
-
-def sqEuclidean(dist1, dist2):
-    P=dist1 
-    Q=dist2 
-    return sum((P-Q)**2)
-    
-def probsymm(dist1, dist2):
-    P=dist1
-    Q=dist2
-    return 2*sum((P-Q)**2/(P+Q))
-
-def topsoe(dist1, dist2):
-    P=dist1
-    Q=dist2
-    return sum(P*np.log(2*P/(P+Q))+Q*np.log(2*Q/(P+Q)))
-
-def hellinger(dist1, dist2):
-    P=dist1
-    Q=dist2
-    return 2 * np.sqrt(np.abs(1 - sum(np.sqrt(P * Q))))

mlquantify/utils/method_purposes/getHist.py

@@ -1,13 +0,0 @@
-import numpy as np
-
-def getHist(scores, nbins):
-
-    breaks = np.linspace(0, 1, int(nbins)+1)
-    breaks = np.delete(breaks, -1)
-    breaks = np.append(breaks,1.1)
-    
-    re = np.repeat(1/(len(breaks)-1), (len(breaks)-1))  
-    for i in range(1,len(breaks)):
-        re[i-1] = (re[i-1] + len(np.where((scores >= breaks[i-1]) & (scores < breaks[i]))[0]) ) / (len(scores)+ 1)
-
-    return re

mlquantify/utils/method_purposes/get_scores.py

@@ -1,33 +0,0 @@
-import pandas as pd
-import numpy as np
-from sklearn.model_selection import StratifiedKFold
-
-def get_scores(X, y, learner, folds:int=10, learner_fitted:bool=False) -> tuple:
-    if isinstance(X, np.ndarray):
-        X = pd.DataFrame(X)
-    if isinstance(y, np.ndarray):
-        y = pd.Series(y)
-        
-    if learner_fitted:
-        probabilities = learner.predict_proba(X)
-        y_label = y
-    else:
-    
-        skf = StratifiedKFold(n_splits=folds)    
-        probabilities = []
-        y_label = []
-        
-        for train_index, valid_index in skf.split(X,y):
-            
-            tr_data = pd.DataFrame(X.iloc[train_index])   #Train data and labels
-            tr_label = y.iloc[train_index]
-            
-            valid_data = pd.DataFrame(X.iloc[valid_index])  #Validation data and labels
-            valid_label = y.iloc[valid_index]
-            
-            learner.fit(tr_data, tr_label)
-            
-            probabilities.extend(learner.predict_proba(valid_data))     #evaluating scores
-            y_label.extend(valid_label)
-    
-    return np.asarray(y_label), np.asarray(probabilities)

mlquantify/utils/method_purposes/moss.py

@@ -1,16 +0,0 @@
-import numpy as np
-
-def MoSS(n:int, alpha:float, m:float):
-  
-  n_pos = int(n*alpha)
-  n_neg = int((1-alpha)*n)
-
-  x_pos = np.arange(1, n_pos, 1)
-  x_neg = np.arange(1, n_neg, 1)
-  
-  syn_plus = np.power(x_pos/(n_pos+1), m)
-  syn_neg = 1 - np.power(x_neg/(n_neg+1), m)
-
-  #moss = np.union1d(syn_plus, syn_neg)
-
-  return syn_plus, syn_neg

mlquantify/utils/method_purposes/ternary_search.py

@@ -1,14 +0,0 @@
-def ternary_search(left, right, f, eps=1e-4):
-    """This function applies Ternary search"""
-
-    while True:
-        if abs(left - right) < eps:
-            return(left + right) / 2
-    
-        leftThird  = left + (right - left) / 3
-        rightThird = right - (right - left) / 3
-    
-        if f(leftThird) > f(rightThird):
-            left = leftThird
-        else:
-            right = rightThird 

mlquantify/utils/method_purposes/tprfpr.py

@@ -1,42 +0,0 @@
-import numpy as np
-
-
-def compute_table(y, y_pred, classes):
-    TP = np.logical_and(y == y_pred, y == classes[1]).sum()
-    FP = np.logical_and(y != y_pred, y == classes[0]).sum()
-    FN = np.logical_and(y != y_pred, y == classes[1]).sum()
-    TN = np.logical_and(y == y_pred, y == classes[0]).sum()
-    return TP, FP, FN, TN
-
-
-def compute_tpr(TP, FN):
-    if TP + FN == 0:
-        return 0
-    return TP / (TP + FN)
-
-
-def compute_fpr(FP, TN):
-    if FP + TN == 0:
-        return 0
-    return FP / (FP + TN)
-
-
-def adjust_threshold(y, probabilities:np.ndarray, classes:np.ndarray) -> tuple:
-    unique_scores = np.linspace(0, 1, 101)
-    
-    tprs = []
-    fprs = []
-    
-    for threshold in unique_scores:
-        y_pred = np.where(probabilities >= threshold, classes[1], classes[0])
-        
-        TP, FP, FN, TN = compute_table(y, y_pred, classes)
-        
-        tpr = compute_tpr(TP, FN)
-        fpr = compute_fpr(FP, TN)
-        
-        tprs.append(tpr)
-        fprs.append(fpr)
-    
-    #best_tpr, best_fpr = self.adjust_threshold(np.asarray(tprs), np.asarray(fprs))
-    return (unique_scores, np.asarray(tprs), np.asarray(fprs))

mlquantify-0.0.11.2.dist-info/RECORD

@@ -1,73 +0,0 @@
-mlquantify/__init__.py,sha256=BGxGCeZhlNsTYZkLoJJ-zcpVDRU4jBFVsz9ZmEZCtvs,166
-mlquantify/base.py,sha256=przWKpQtoTT6ekbyTrAU3Kp_JsQ1982rAXWX_oAoSQM,8393
-mlquantify/model_selection.py,sha256=zN-qkrCe35GoJ8u1_Ab3EKXvrnAppk68Fj5kQVi61nU,8617
-mlquantify/classification/__init__.py,sha256=zxE6_ouh3kJVL56aJAhpFh36EBWKq9U4IcID4noROPQ,26
-mlquantify/classification/pwkclf.py,sha256=K1XBgI9FIh1Yu571bzdw8PM-TJXFGOQAzP4ewDV9b3Y,2323
-mlquantify/evaluation/__init__.py,sha256=_7orbRyYuJydD_W9o5l9Ko_-EopGGhewekoEhR82S3Q,48
-mlquantify/evaluation/measures/__init__.py,sha256=JvxIm3k31EFBzm-4Guj9Huh--B7u-o3gvln3VSFK2nk,761
-mlquantify/evaluation/measures/ae.py,sha256=eY8oKfj7TIpbNCsEfbkbeVVduSAaiKE5Vxy7xACwrL8,363
-mlquantify/evaluation/measures/bias.py,sha256=AmTZ9dP5XW6ZR-gdBfOF008IzVFeBNeL2SIuSLkABQc,497
-mlquantify/evaluation/measures/kld.py,sha256=f443cf31Sm904zEwk0q1093XwvEEQbroHUzNLKJj-BI,341
-mlquantify/evaluation/measures/mse.py,sha256=VS38G83ygVz_qxtsjqa-tTGbPVERQOraY_aga5JmVuo,408
-mlquantify/evaluation/measures/nae.py,sha256=D5W2qiD1EC53uy7AILRHvdZNvAcAQkLTuFNFNmHjkEs,499
-mlquantify/evaluation/measures/nkld.py,sha256=UsTDZP-CjiEgQjfyoKynZntpFV8msYPrEma3GtHK1-s,491
-mlquantify/evaluation/measures/nrae.py,sha256=iTxEG7k6DQRieSbwKrHfcynmbRR-qCviudDecoRkmdk,574
-mlquantify/evaluation/measures/rae.py,sha256=KYa9HY7k5w3acMp5yUSMVuwZIdzeUB9CzkSA-jpXn7Y,416
-mlquantify/evaluation/measures/se.py,sha256=aScxX56dmbSj1HxubD8Dlq4gTmbNrA-H3AdE145wgDI,396
-mlquantify/evaluation/protocol/_Protocol.py,sha256=XsLsu-sDQxHVyRqc-vGAs4407H5IJGSYAuH4sWAYQL8,7752
-mlquantify/evaluation/protocol/__init__.py,sha256=RO3fHIvhAK95t8EUaD67JfJV2WeLb17HMqbXo3LcUSI,42
-mlquantify/evaluation/protocol/app.py,sha256=WJ2OaYe49R8JqCoZDy6gMN50eIQ7jThPDT5W5lSRlK0,5713
-mlquantify/evaluation/protocol/npp.py,sha256=c287_9LmxYvv72hh2iwoCwSkwqTeFvknKOWWG4Jq0QY,1117
-mlquantify/methods/__init__.py,sha256=rvpN5T6vXdfX1bOHKYGC0aKZMc5bHSPb-pCVQ3mlb08,627
-mlquantify/methods/aggregative/__init__.py,sha256=rBtSfgTsTIjbH5rJhQ9V05n68o-9hm9QNZzxRCh2VME,209
-mlquantify/methods/aggregative/cc.py,sha256=HXFgcLqyM35CTszBn5UmUmT60Z1J1Ow0i4lZf5BctH8,1123
-mlquantify/methods/aggregative/emq.py,sha256=3N4PQhTlBu6vBwOaEpcNZf2QYNBF2XC8cCH3qsyKt9Y,3208
-mlquantify/methods/aggregative/fm.py,sha256=RgXVwsdoZsWV_DanvzcsRmll_e2Etvl27PNI7iYM9Nw,2912
-mlquantify/methods/aggregative/gac.py,sha256=gTIRqMN0S7teheSOgrk2NB80UxfC-KfbNuk0A1tflh8,3640
-mlquantify/methods/aggregative/gpac.py,sha256=VcDCcEYXiknEOTwVDGOXWeZCJS9T6vd4YFqEbnUB3YU,3531
-mlquantify/methods/aggregative/pcc.py,sha256=8WuiWFrYvskx0Xd2wTDgcn-GyswwB5hv-VH6HaRkilY,1251
-mlquantify/methods/aggregative/pwk.py,sha256=JCUzS8hrsiFMacLh00FR4Xhk7zhe4Vy4za-0QeFr-l8,1466
-mlquantify/methods/aggregative/ThreholdOptm/_ThreholdOptimization.py,sha256=amgklOfPe-htQIhuDb3l4usqj-cVkGFa7z0KXYmibUM,2433
-mlquantify/methods/aggregative/ThreholdOptm/__init__.py,sha256=ALB-ZEl9M_DyHr3U9PEw6E9XSMFfwci_aSwbpyzvp0E,155
-mlquantify/methods/aggregative/ThreholdOptm/acc.py,sha256=tgcMhYW9cD66j0T6mWDulaxP9-FA1mNozvlaKMQV2UQ,1082
-mlquantify/methods/aggregative/ThreholdOptm/max.py,sha256=A-_0RQ-HAiTE2FfeNvcInqauXpzn8xtSf0LDiuC5wDk,824
-mlquantify/methods/aggregative/ThreholdOptm/ms.py,sha256=BpVrDaiCZa8xe1_YX9qhGCsOAcCXZ_3EQF5ZCHWRCn8,739
-mlquantify/methods/aggregative/ThreholdOptm/ms2.py,sha256=Pxxc4p_41KLcNUaN0fhjih3mSVMJhoZrm-KUy45paT4,852
-mlquantify/methods/aggregative/ThreholdOptm/pacc.py,sha256=zfRQhklB8NuvQAn8-a1hJ9sm6iG6yRGIWh-xlLTnU3M,1432
-mlquantify/methods/aggregative/ThreholdOptm/t50.py,sha256=-zWNDXdGpW7CR-9O6MUQYOBqMuH15lLV-uK0u8nIAYA,728
-mlquantify/methods/aggregative/ThreholdOptm/x.py,sha256=Lwn5MtaL9tb4eRFMrFxerUjmumh2US90KvDfdNQxvF8,759
-mlquantify/methods/aggregative/mixtureModels/_MixtureModel.py,sha256=pcnCN0IArb_AJ71AyUnIt0uVPhN9IWnXZF9ad1d0g8c,3336
-mlquantify/methods/aggregative/mixtureModels/__init__.py,sha256=F7QvGhVkG7NEHjnau_fNm7T9MLCUUDwfrrNvncqPpPI,117
-mlquantify/methods/aggregative/mixtureModels/dys.py,sha256=JC3h_gdIYG-5pphl7C6Ez8Kbp0UPbccqX8ZVcsTAI3g,2356
-mlquantify/methods/aggregative/mixtureModels/dys_syn.py,sha256=GGt9TOXGUBBD9PdiozT6QpC-IGa6QvLf1QAGEI7El8s,3906
-mlquantify/methods/aggregative/mixtureModels/hdy.py,sha256=JykK4Fg5yPKmEuL1aAqsG9wnrmTbXNuxbK4ugI1XNBo,1986
-mlquantify/methods/aggregative/mixtureModels/smm.py,sha256=2r82umOXqOrffVO-SdnyUzsJKg6hz5_z82HzNsn7GRY,1050
-mlquantify/methods/aggregative/mixtureModels/sord.py,sha256=Kz5YAXd3RezeTI66wfrnXxY_AXDos44WS8N2fYE4oxA,3166
-mlquantify/methods/meta/__init__.py,sha256=uj--leWdOrpBs0u_djhCYlLCrQo3GIxg0AoJyAkHC-c,30
-mlquantify/methods/meta/ensemble.py,sha256=rX9fyGi6xMYVUo0jm_rttnSDTDt_XokvzZJUWDPxQTM,10396
-mlquantify/methods/non_aggregative/__init__.py,sha256=HD34lwNmAkw26qlEA5PDHay9V6ShgFiQvlPipOsrDAs,20
-mlquantify/methods/non_aggregative/hdx.py,sha256=vwodV_Z89_be8HBOSriX3lsFhzmPZVLdOgKewa6la-E,2420
-mlquantify/plots/__init__.py,sha256=IDnv_KVALIsVuohiudclnIMSM5F1dNRxUFpjygLblBI,118
-mlquantify/plots/distribution_plot.py,sha256=8l22Lq6LhlOd3yv6gHX6wg2p1MTozYASyNzPcLlPHzk,4038
-mlquantify/plots/protocol_plot.py,sha256=DfkCSHELr9lyyxMqeGNJgx0iywODQmH8EL5tlMjeAFQ,6618
-mlquantify/utils/__init__.py,sha256=VKplOsrL4ONf0-9anhcWFOxXjvGSQTH0Kh922s_hGb0,63
-mlquantify/utils/general_purposes/__init__.py,sha256=-Pwx1t2M_rGCEHxIc2TyomSe92w6U5Bdp6wtpsdcMZI,380
-mlquantify/utils/general_purposes/convert_col_to_array.py,sha256=Pq6_U6BdsIAl4Vr_836_vM-g2iRQAJ1b4kGOsYoFukI,560
-mlquantify/utils/general_purposes/generate_artificial_indexes.py,sha256=L_Sb1hBYGllCxDbYKRNY_qqjCfSbbkXo6E1XuaWxQMs,1049
-mlquantify/utils/general_purposes/get_real_prev.py,sha256=nHSXaxAdp-rznyhauN7ta_1QCDrlfCZSJWxxQQ4_pvE,266
-mlquantify/utils/general_purposes/load_quantifier.py,sha256=6BfObUBVJ7_v-pzP-cQlMpblmg6ygpvDRTimOhMWepw,77
-mlquantify/utils/general_purposes/make_prevs.py,sha256=lamVz-MTRDP4bqDjS4xm2SMa3YpnMcL__1OF6ZpEX2I,661
-mlquantify/utils/general_purposes/normalize.py,sha256=kIRG22249IkBuDBGP-qQbLsH-edPFC8gPnJS_huxLhY,785
-mlquantify/utils/general_purposes/parallel.py,sha256=vkert2m-A5Rs_VKhLUk84nZ0scIVPFadvVsTF2bItaU,218
-mlquantify/utils/general_purposes/round_protocol_df.py,sha256=74zS7ws7mgzjObv6xoQi7rvH2xskschHF93czoFaVFY,474
-mlquantify/utils/method_purposes/__init__.py,sha256=MFB3LtYTsWuETmyFokn8EZoK2wwPZspCknIMdutLLCo,276
-mlquantify/utils/method_purposes/distances.py,sha256=l5neBoqLN_Npyf2L9VB19V_RHpB2w9AJuddTQ2pFzxU,428
-mlquantify/utils/method_purposes/getHist.py,sha256=dgO57Wo-Sbix6h1ixbT2XIKuRU0p-lZNLGI0ZGwadkM,402
-mlquantify/utils/method_purposes/get_scores.py,sha256=qdIVYUS8xd8Vt86k19yETDNfibTXaTur5pCrMA1b254,1151
-mlquantify/utils/method_purposes/moss.py,sha256=CVDDMHxPBnl_U2hz7Aqvne7jhB2mBUsVzTTsaiLQhOc,352
-mlquantify/utils/method_purposes/ternary_search.py,sha256=JpNrfJsA5kWuanVW_hyMucy7rQ9UzTSgazFpTRi9jMI,416
-mlquantify/utils/method_purposes/tprfpr.py,sha256=VKniG5aK8IwAA2fXEhkdHtwnx1zHH12qhwS4kKW5Dlo,1181
-mlquantify-0.0.11.2.dist-info/METADATA,sha256=CQ6GvMVgM4JfD6KW4vXoDAixa35QM1zOFs5Erdm3EEM,4717
-mlquantify-0.0.11.2.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-mlquantify-0.0.11.2.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
-mlquantify-0.0.11.2.dist-info/RECORD,,