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

mlquantify/plots.py

@@ -0,0 +1,367 @@
+import numpy as np
+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
+
+
+
+
+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
+        Color in hexadecimal format.
+    saturation_factor : float, optional
+        Factor to adjust the saturation. Default is 5.
+    
+    Returns
+    -------
+    str
+        Color in hexadecimal format with adjusted saturation.
+    """
+    # 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.
+    
+    Parameters
+    ----------
+    table_protocol : pd.DataFrame
+        DataFrame containing the protocol results.
+    x : str
+        Column name to use as the x-axis.
+    y : str
+        Column name to use as the y-axis.
+    methods : List[str], optional
+        List of quantifiers to plot. If not provided, all quantifiers will be plotted.
+    title : str, optional
+        Title of the plot. Default is None.
+    legend : bool, optional
+        Whether to display a legend. Default is True.
+    save_path : str, optional
+        File path to save the plot image. If not provided, the plot will not be saved.
+    order : str, optional
+        Order to plot the methods. If 'rank', methods will be ordered by median value.
+    plot_params : Dict[str, Any], optional
+        Dictionary of custom plotting parameters to apply. Default is None
+    """
+    # 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.
+    
+    Parameters
+    ----------
+    table_protocol : pd.DataFrame
+        DataFrame containing the protocol results.
+    methods : Union[List[str], str, None]
+        List of quantifiers to plot. If not provided, all quantifiers will be plotted.
+    x : str
+        Column name to use as the x-axis.
+        - If 'ALPHA', the real prevalence of the positive class will be used.
+        - You can also use any other column name, as long as the x has the same name.
+    y : str
+        Column name to use as the y-axis.
+    title : str, optional
+        Title of the plot. Default is None.
+    legend : bool, optional
+        Whether to display a legend. Default is True.
+    save_path : str, optional
+        File path to save the plot image. If not provided, the plot will not be saved.
+    group_by : str, optional
+        Column to group the data. Default is 'mean'.
+    pos_alpha : int, optional
+        Position of the positive class in the 'PREVS' column, this attribute only works for binary problems. Default is 1.
+    plot_params : Dict[str, Any], optional
+        Dictionary of custom plotting parameters to apply. Default is None.
+    """
+    # 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()
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+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.
+
+    Parameters
+    ----------
+    values : Union[List, np.ndarray]
+        List or array of values to plot.
+    labels : Union[List, np.ndarray]
+        List or array of labels corresponding to the values.
+    bins : int, optional
+        Number of bins to use for the histogram. Default is 30.
+    title : str, optional
+        Title of the plot. Default is None.
+    legend : bool, optional
+        Whether to display a legend. Default is True.
+    save_path : str, optional
+        File path to save the plot image. If not provided, the plot will not be saved.
+    plot_params : Dict[str, Any], optional
+        Dictionary of custom plotting parameters to apply. Default is None.
+    
+    Raises
+    ------
+    AssertionError
+        If the number of value sets does not match the number of labels.
+    """
+    
+    # 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."
+    
+    if isinstance(values, list):
+        values = np.asarray(values)
+    if isinstance(labels, list):
+        labels = np.asarray(labels)
+    
+    
+    # Apply custom plotting parameters if provided
+    if plot_params:
+        plt.rcParams.update(plot_params)
+
+    if values.shape[1] > 1:
+        num_plots = values.shape[1]  # Number of columns in `values`
+        cols = int(np.ceil(np.sqrt(num_plots)))
+        rows = int(np.ceil(num_plots / cols))
+
+        fig, axs = plt.subplots(rows, cols, figsize=(cols * 5, rows * 4))
+        axs = axs.flatten()
+    
+    # Create the overlaid histogram
+    for i, label in enumerate(np.unique(labels)):
+        if values.shape[1] > 1:
+            for j, lab in enumerate(np.unique(labels)):
+                value_set = values[:, j][label == labels]
+                axs[i].hist(value_set, bins=bins, color=COLORS[j % len(COLORS)], edgecolor='black', alpha=0.5, label=lab)
+                axs[i].set_xlim([0, 1])  # Fix x-axis range between 0 and 1
+        else:
+            value_set = values[label == labels]
+            plt.hist(value_set, bins=bins, color=COLORS[i % len(COLORS)], edgecolor='black', alpha=0.5, label=label)
+            plt.xlim([0, 1])  # Fix x-axis range between 0 and 1
+
+    if values.shape[1] > 1:
+        for i in range(i + 1, len(axs)):
+            fig.delaxes(axs[i])
+    
+    # Add title to the plot if provided
+    if title:
+        if values.shape[1] > 1:
+            for i in range(values.shape[1]):
+                axs[i].set_title(f'{title} for class {i+1}')
+        else:
+            plt.title(title)
+
+    # Add legend to the plot if enabled
+    if legend:
+        if values.shape[1] > 1:
+            for i in range(values.shape[1]):
+                axs[i].legend(loc='upper right')
+        else:
+            plt.legend(loc='upper right')
+
+    # Set axis labels
+    if values.shape[1] > 1:
+        for i in range(values.shape[1]):
+            axs[i].set_xlabel('Values')
+            axs[i].set_ylabel('Frequency')
+    else:
+        plt.xlabel('Values')
+        plt.ylabel('Frequency')
+
+    # Adjust layout to prevent overlapping
+    plt.subplots_adjust(hspace=0.9, wspace=0.4)
+    plt.tight_layout()
+
+    # Save the figure if a path is specified
+    if save_path:
+        plt.savefig(save_path, bbox_inches='tight')
+
+    # Show the plot
+    plt.show()
+
+

mlquantify/utils/__init__.py

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

mlquantify/utils/general.py

@@ -0,0 +1,334 @@
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed, load
+from collections import defaultdict
+import itertools
+
+
+def convert_columns_to_arrays(df, columns:list = ['PRED_PREVS', 'REAL_PREVS']):
+    """
+    Converts specified columns in a DataFrame from strings of arrays to NumPy arrays.
+    
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame to convert.
+    columns : list
+        List of columns to convert.
+    
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with the specified columns converted to NumPy arrays.
+    """
+    for col in columns:
+        df[col] = df[col].apply(lambda x: np.fromstring(x.strip('[]'), sep=' ') if isinstance(x, str) else x)
+    return df
+
+
+
+
+
+def generate_artificial_indexes(y, prevalence: list, sample_size:int, classes:list):
+    """
+    Generate indexes for a stratified sample based on the prevalence of each class.
+    
+    Parameters
+    ----------
+    y : np.ndarray
+        Array of class labels.
+    prevalence : list
+        List of prevalences for each class.
+    sample_size : int
+        Number of samples to generate.
+    classes : list
+        List of unique classes.
+        
+    Returns
+    -------
+    list
+        List of indexes for the stratified sample.
+    """        
+    # 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
+
+
+
+
+def generate_artificial_prevalences(n_dim: int, n_prev: int, n_iter: int) -> np.ndarray:
+    """Generates n artificial prevalences with n dimensions.
+
+    Parameters
+    ----------
+    n_dim : int
+        Number of dimensions.
+    n_prev : int
+        Number of prevalences to generate.
+    n_iter : int
+        Number of iterations.
+    
+    Returns
+    -------
+    np.ndarray
+        Array of artificial prevalences.
+    
+    """
+    s = np.linspace(0., 1., n_prev, endpoint=True)
+    prevs = np.array([p + (1 - sum(p),) for p in itertools.product(*(s,) * (n_dim - 1)) if sum(p) <= 1])
+    
+    return np.repeat(prevs, n_iter, axis=0) if n_iter > 1 else prevs
+
+
+
+
+
+
+
+
+def get_real_prev(y) -> dict:
+    """
+    Get the real prevalence of each class in the target array.
+    
+    Parameters
+    ----------
+    y : np.ndarray or pd.Series
+        Array of class labels.
+        
+    Returns
+    -------
+    dict
+        Dictionary of class labels and their corresponding prevalence.
+    """
+    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
+
+
+
+
+
+
+
+
+
+def load_quantifier(path:str):
+    """
+    Load a quantifier from a file.
+    
+    Parameters
+    ----------
+    path : str
+        Path to the file containing the quantifier.
+    
+    Returns
+    -------
+    Quantifier
+        Loaded quantifier.
+    """
+    return load(path)
+
+
+
+
+
+
+
+
+
+def make_prevs(ndim:int) -> list:
+    """
+    Generate a list of n_dim values uniformly distributed between 0 and 1 that sum exactly to 1.
+    
+    Parameters
+    ----------
+    ndim : int
+        Number of dimensions.
+    
+    Returns
+    -------
+    list
+        List of n_dim values uniformly distributed between 0 and 1 that sum exactly 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+def normalize_prevalence(prevalences: np.ndarray, classes:list):
+    """
+    Normalize the prevalence of each class to sum to 1.
+    
+    Parameters
+    ----------
+    prevalences : np.ndarray
+        Array of prevalences.
+    classes : list
+        List of unique classes.
+    
+    Returns
+    -------
+    dict
+        Dictionary of class labels and their corresponding prevalence.
+    """
+    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)
+
+
+
+
+
+
+
+def parallel(func, elements, n_jobs: int = 1, *args):
+    """
+    Run a function in parallel on a list of elements.
+    
+    Parameters
+    ----------
+    func : function
+        Function to run in parallel.
+    elements : list
+        List of elements to run the function on.
+    n_jobs : int
+        Number of jobs to run in parallel.
+    args : tuple
+        Additional arguments to pass to the function.
+    
+    Returns
+    -------
+    list
+        List of results from running the function on each element.
+    """
+    return Parallel(n_jobs=n_jobs, backend="threading")(
+        delayed(func)(e, *args) for e in elements
+    )
+    
+    
+    
+    
+
+
+
+
+
+
+def round_protocol_df(dataframe: pd.DataFrame, frac: int = 3):
+    """
+    Round the columns of a protocol dataframe to a specified number of decimal places.
+    
+    Parameters
+    ----------
+    dataframe : pd.DataFrame
+        Protocol dataframe to round.
+    frac : int
+        Number of decimal places to round to.
+    
+    Returns
+    -------
+    pd.DataFrame
+        Protocol dataFrame with the columns rounded to the specified number of decimal places.
+    """
+    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)
+
+
+
+
+def get_measure(measure:str):
+    """
+    Get the measure from the evaluation module.
+    
+    Parameters
+    ----------
+    measure : str
+        Measure to get.
+    
+    Returns
+    -------
+    Measure
+        Measure function from the evaluation module.
+    """
+    from ..evaluation import MEASURES
+    return MEASURES.get(measure)
+
+
+def get_method(method: str):
+    """
+    Get the method from the methods module.
+    
+    Parameters
+    ----------
+    method : str
+        Method to get.
+    
+    Returns
+    -------
+    Method
+        Method class from the methods module.
+    """
+    from ..methods import METHODS
+    return METHODS.get(method)