mlquantify 0.0.1__py3-none-any.whl

mlquantify/model_selection.py

@@ -0,0 +1,232 @@
+from .base import Quantifier
+from typing import Union, List
+import itertools
+from tqdm import tqdm
+import signal
+from copy import deepcopy
+import numpy as np
+from sklearn.model_selection import train_test_split
+from .utils import parallel
+from .evaluation import get_measure, APP, NPP
+
+class GridSearchQ(Quantifier):
+    """
+    Hyperparameter optimization for quantification models using grid search.
+
+    Args:
+        model (Quantifier): The base quantification model.
+        param_grid (dict): Hyperparameters to search over.
+        protocol (str, optional): Quantification protocol ('app' or 'npp'). Defaults to 'app'.
+        n_prevs (int, optional): Number of prevalence points for APP. Defaults to None.
+        n_repetitions (int, optional): Number of repetitions for NPP. Defaults to 1.
+        scoring (Union[List[str], str], optional): Metric(s) for evaluation. Defaults to "mae".
+        refit (bool, optional): Refit model on best parameters. Defaults to True.
+        val_split (float, optional): Proportion of data for validation. Defaults to 0.4.
+        n_jobs (int, optional): Number of parallel jobs. Defaults to 1.
+        random_seed (int, optional): Seed for reproducibility. Defaults to 42.
+        timeout (int, optional): Max time per parameter combination (seconds). Defaults to -1.
+        verbose (bool, optional): Verbosity of output. Defaults to False.
+    """
+
+    def __init__(self,
+                 model: Quantifier,
+                 param_grid: dict,
+                 protocol: str = 'app',
+                 n_prevs: int = None,
+                 n_repetitions: int = 1,
+                 scoring: Union[List[str], str] = "ae",
+                 refit: bool = True,
+                 val_split: float = 0.4,
+                 n_jobs: int = 1,
+                 random_seed: int = 42,
+                 timeout: int = -1,
+                 verbose: bool = False):
+        
+        self.model = model
+        self.param_grid = param_grid
+        self.protocol = protocol.lower()
+        self.n_prevs = n_prevs
+        self.n_repetitions = n_repetitions
+        self.refit = refit
+        self.val_split = val_split
+        self.n_jobs = n_jobs
+        self.random_seed = random_seed
+        self.timeout = timeout
+        self.verbose = verbose
+        self.scoring = [get_measure(measure) for measure in (scoring if isinstance(scoring, list) else [scoring])]
+
+        assert self.protocol in {'app', 'npp'}, 'Unknown protocol; valid ones are "app" or "npp".'
+        
+        if self.protocol == 'npp' and self.n_repetitions <= 1:
+            raise ValueError('For "npp" protocol, n_repetitions must be greater than 1.')
+
+    def sout(self, msg):
+        """Prints messages if verbose is True."""
+        if self.verbose:
+            print(f'[{self.__class__.__name__}]: {msg}')
+
+    def __get_protocol(self, model, sample_size):
+        """Get the appropriate protocol instance.
+
+        Args:
+            model (Quantifier): The quantification model.
+            sample_size (int): The sample size for batch processing.
+
+        Returns:
+            object: Instance of APP or NPP protocol.
+        """
+        protocol_params = {
+            'models': model,
+            'batch_size': sample_size,
+            'n_iterations': self.n_repetitions,
+            'n_jobs': self.n_jobs,
+            'verbose': False,
+            'random_state': 35,
+            'return_type': "predictions"
+        }
+        return APP(n_prevs=self.n_prevs, **protocol_params) if self.protocol == 'app' else NPP(**protocol_params)
+
+    def fit(self, X, y):
+        """Fit the quantifier model and perform grid search.
+
+        Args:
+            X (array-like): Training features.
+            y (array-like): Training labels.
+
+        Returns:
+            self: Fitted GridSearchQ instance.
+        """
+        X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=self.val_split, random_state=self.random_seed)
+        param_combinations = list(itertools.product(*self.param_grid.values()))
+        best_score, best_params = None, None
+        
+        if self.timeout > 0:
+            signal.signal(signal.SIGALRM, self._timeout_handler)
+
+        def evaluate_combination(params):
+            """Evaluate a single combination of hyperparameters.
+
+            Args:
+                params (tuple): A tuple of hyperparameter values.
+
+            Returns:
+                float or None: The evaluation score, or None if timeout occurred.
+            """
+            
+            if self.verbose:
+                print(f"\tEvaluate Combination for {str(params)}")
+            
+            
+            model = deepcopy(self.model)
+            model.set_params(**dict(zip(self.param_grid.keys(), params)))
+            protocol_instance = self.__get_protocol(model, len(y_train))
+
+            try:
+                if self.timeout > 0:
+                    signal.alarm(self.timeout)
+
+                protocol_instance.fit(X_train, y_train)
+                _, real_prevs, pred_prevs = protocol_instance.predict(X_val, y_val)
+                scores = [np.mean([measure(rp, pp) for rp, pp in zip(real_prevs, pred_prevs)]) for measure in self.scoring]
+
+                if self.timeout > 0:
+                    signal.alarm(0)
+                    
+                    
+                    
+                if self.verbose:
+                    print(f"\t\\--ended evaluation of {str(params)}")
+
+                return np.mean(scores) if scores else None
+            except TimeoutError:
+                self.sout(f'Timeout reached for combination {params}.')
+                return None
+
+        results = parallel(
+            evaluate_combination,
+            tqdm(param_combinations, desc="Evaluating combination", total=len(param_combinations)) if self.verbose else param_combinations,
+            n_jobs=self.n_jobs
+        )
+        
+        for score, params in zip(results, param_combinations):
+            if score is not None and (best_score is None or score < best_score):
+                best_score, best_params = score, params
+
+        self.best_score_ = best_score
+        self.best_params_ = dict(zip(self.param_grid.keys(), best_params))
+        self.sout(f'Optimization complete. Best score: {self.best_score_}, with parameters: {self.best_params_}.')
+
+        if self.refit and self.best_params_:
+            self.model.set_params(**self.best_params_)
+            self.model.fit(X, y)
+            self.best_model_ = self.model
+
+        return self
+    
+    def predict(self, X):
+        """Make predictions using the best found model.
+
+        Args:
+            X (array-like): Data to predict on.
+
+        Returns:
+            array-like: Predictions.
+        """
+        if not hasattr(self, 'best_model_'):
+            raise RuntimeError("The model has not been fitted yet.")
+        return self.best_model_.predict(X)
+    
+    @property
+    def classes_(self):
+        """Get the classes of the best model.
+
+        Returns:
+            array-like: The classes.
+        """
+        return self.best_model_.classes_
+
+    def set_params(self, **parameters):
+        """Set the hyperparameters for grid search.
+
+        Args:
+            parameters (dict): Hyperparameters to set.
+        """
+        self.param_grid = parameters
+
+    def get_params(self, deep=True):
+        """Get the parameters of the best model.
+
+        Args:
+            deep (bool, optional): If True, will return the parameters for this estimator and contained subobjects. Defaults to True.
+
+        Returns:
+            dict: Parameters of the best model.
+        """
+        if hasattr(self, 'best_model_'):
+            return self.best_model_.get_params()
+        raise ValueError('get_params called before fit')
+
+    def best_model(self):
+        """Return the best model after fitting.
+
+        Returns:
+            Quantifier: The best model.
+
+        Raises:
+            ValueError: If called before fitting.
+        """
+        if hasattr(self, 'best_model_'):
+            return self.best_model_
+        raise ValueError('best_model called before fit')
+
+    def _timeout_handler(self, signum, frame):
+        """Handle timeouts during evaluation.
+
+        Args:
+            signum (int): Signal number.
+            frame (object): Current stack frame.
+        
+        Raises:
+            TimeoutError: When the timeout is reached.
+        """
+        raise TimeoutError()

mlquantify/plots/__init__.py

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

mlquantify/plots/distribution_plot.py

@@ -0,0 +1,109 @@
+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()

mlquantify/plots/protocol_plot.py

@@ -0,0 +1,157 @@
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+import pandas as pd
+from typing import List, Optional, Dict, Any, Union
+from pathlib import Path
+
+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 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 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)])):
+        method_data = table[table['QUANTIFIER'] == method]
+        y_data = real if y == "ALPHA" else method_data[y]
+        ax.plot(method_data[x], y_data, color=COLORS[i % len(COLORS)], marker=marker, label=method, **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/__init__.py

@@ -0,0 +1,2 @@
+from .general_purposes import *
+from .method_purposes import *

mlquantify/utils/general_purposes/__init__.py

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,9 @@
+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

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

mlquantify/utils/general_purposes/make_prevs.py

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,21 @@
+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))))