diff --git a/dabest/_modidx.py b/dabest/_modidx.py index d51151af..e3e32781 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -107,6 +107,36 @@ 'dabest/misc_tools.py'), 'dabest.misc_tools.show_legend': ('API/misc_tools.html#show_legend', 'dabest/misc_tools.py'), 'dabest.misc_tools.unpack_and_add': ('API/misc_tools.html#unpack_and_add', 'dabest/misc_tools.py')}, + 'dabest.multi': { 'dabest.multi.MultiContrast': ('API/multi.html#multicontrast', 'dabest/multi.py'), + 'dabest.multi.MultiContrast.__init__': ('API/multi.html#multicontrast.__init__', 'dabest/multi.py'), + 'dabest.multi.MultiContrast.__repr__': ('API/multi.html#multicontrast.__repr__', 'dabest/multi.py'), + 'dabest.multi.MultiContrast._extract_data': ('API/multi.html#multicontrast._extract_data', 'dabest/multi.py'), + 'dabest.multi.MultiContrast._extract_single_contrast': ( 'API/multi.html#multicontrast._extract_single_contrast', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast._validate_and_parse_structure': ( 'API/multi.html#multicontrast._validate_and_parse_structure', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast._validate_ci_type': ( 'API/multi.html#multicontrast._validate_ci_type', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast._validate_contrast_consistency': ( 'API/multi.html#multicontrast._validate_contrast_consistency', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast._validate_effect_size': ( 'API/multi.html#multicontrast._validate_effect_size', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast._validate_effect_size_compatibility': ( 'API/multi.html#multicontrast._validate_effect_size_compatibility', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast._validate_individual_dabest_obj': ( 'API/multi.html#multicontrast._validate_individual_dabest_obj', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast.bootstraps': ('API/multi.html#multicontrast.bootstraps', 'dabest/multi.py'), + 'dabest.multi.MultiContrast.confidence_intervals': ( 'API/multi.html#multicontrast.confidence_intervals', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast.effect_sizes': ('API/multi.html#multicontrast.effect_sizes', 'dabest/multi.py'), + 'dabest.multi.MultiContrast.forest_plot': ('API/multi.html#multicontrast.forest_plot', 'dabest/multi.py'), + 'dabest.multi.MultiContrast.get_bootstrap_by_position': ( 'API/multi.html#multicontrast.get_bootstrap_by_position', + 'dabest/multi.py'), + 'dabest.multi.MultiContrast.vortexmap': ('API/multi.html#multicontrast.vortexmap', 'dabest/multi.py'), + 'dabest.multi._sample_bootstrap': ('API/multi.html#_sample_bootstrap', 'dabest/multi.py'), + 'dabest.multi._spiralize': ('API/multi.html#_spiralize', 'dabest/multi.py'), + 'dabest.multi.combine': ('API/multi.html#combine', 'dabest/multi.py'), + 'dabest.multi.vortexmap': ('API/multi.html#vortexmap', 'dabest/multi.py')}, 'dabest.plot_tools': { 'dabest.plot_tools.SwarmPlot': ('API/plot_tools.html#swarmplot', 'dabest/plot_tools.py'), 'dabest.plot_tools.SwarmPlot.__init__': ( 'API/plot_tools.html#swarmplot.__init__', 'dabest/plot_tools.py'), diff --git a/dabest/multi.py b/dabest/multi.py new file mode 100644 index 00000000..e440defa --- /dev/null +++ b/dabest/multi.py @@ -0,0 +1,729 @@ +# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/API/multi.ipynb. + +# %% auto 0 +__all__ = ['MultiContrast', 'combine', 'vortexmap'] + +# %% ../nbs/API/multi.ipynb 3 +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt +import seaborn as sns +import warnings +from typing import List, Optional, Union, Tuple, Dict, Any + + +# %% ../nbs/API/multi.ipynb 6 +class MultiContrast: + """ + Unified multiple contrast object for forest plots and vortexmaps. + + Takes raw dabest objects and provides validated, processed data + for downstream visualizations. + """ + + def __init__(self, + dabest_objs: Union[List, List[List]], + labels: Optional[List[str]] = None, + row_labels: Optional[List[str]] = None, + effect_size: str = "mean_diff", + ci_type: str = "bca"): + """ + Initialize MultiContrast object with checking. + + Parameters + ---------- + dabest_objs : Union[List, List[List]] + Raw dabest objects. Can be: + - 1D: [dabest_obj1, dabest_obj2, ...] + - 2D: [[dabest_obj1, dabest_obj2], [dabest_obj3, dabest_obj4]] + labels : Optional[Union[List[str], List[List[str]]]], default=None + Labels matching the contrast array structure. If None, defaults will be generated. + effect_size : str, default="mean_diff" + Effect size to extract from dabest objects + ci_type : str, default="bca" + Confidence interval type + """ + # Store raw inputs for validation + self._raw_dabest_objs = dabest_objs + self._raw_labels = labels + self._raw_row_labels = row_labels + + # Validate and process inputs + self.effect_size = self._validate_effect_size(effect_size) + self.ci_type = self._validate_ci_type(ci_type) + + # Process structure (adapts forest_plot logic to handle 2D) + self.structure = self._validate_and_parse_structure(dabest_objs, labels) + + # Validate all dabest objects consistency + self.contrast_type = self._validate_contrast_consistency() + + # Extract data (adapts forest_plot's load_plot_data logic) + self._bootstrap_data = None + self._effect_size_data = None + self._ci_data = None + + def _validate_effect_size(self, effect_size: str) -> str: + """Validate effect size parameter (from forest_plot).""" + possible_effect_sizes = [ + 'mean_diff', 'median_diff', 'cohens_d', + 'cohens_h', 'cliffs_delta', 'hedges_g', 'delta_g' + ] + + if not isinstance(effect_size, str) or effect_size not in possible_effect_sizes: + raise TypeError( + f"effect_size must be one of: {possible_effect_sizes}" + ) + return effect_size + + def _validate_ci_type(self, ci_type: str) -> str: + """Validate CI type parameter (from forest_plot).""" + if ci_type not in ('bca', 'pct'): + raise TypeError("ci_type must be either 'bca' or 'pct'") + return ci_type + + def _validate_and_parse_structure(self, dabest_objs, labels): + """ + Validate and parse contrast structure, combining forest_plot + validation with vortexmap's 2D handling. + """ + # Basic validation (from forest_plot) + if not isinstance(dabest_objs, (list, tuple)) or len(dabest_objs) == 0: + raise ValueError("dabest_objs must be a non-empty list") + + # Determine if 1D or 2D structure + if isinstance(dabest_objs[0], (list, tuple)): + # 2D structure (can be used to plot vortexmap or a stack of forest plots) + structure_type = "2D" + dabest_objs_2d = dabest_objs + n_rows = len(dabest_objs) + n_cols = len(dabest_objs[0]) + + # Validate rectangular structure + for i, row in enumerate(dabest_objs): + if not isinstance(row, (list, tuple)): + raise TypeError(f"Row {i} must be a list/tuple in 2D structure") + if len(row) != n_cols: + raise ValueError("All rows must have the same number of dabest_objs") + + # Handle 2D labels + if labels: + if not isinstance(labels, (list, tuple)): + raise TypeError("labels must be a list for 2D dabest_objs") + if len(labels) != n_cols: + raise ValueError("Number of labels must match number of columns of dabest_objs") + col_labels = labels + else: + col_labels = [f"Contrast {i+1}" for i in range(n_cols)] + # Handle row_labels - use self._raw_row_labels if available + if hasattr(self, '_raw_row_labels') and self._raw_row_labels: + if not isinstance(self._raw_row_labels, (list, tuple)): + raise TypeError("row_labels must be a list for 2D dabest_objs") + if len(self._raw_row_labels) != n_rows: + raise ValueError("Number of row_labels must match number of rows of dabest_objs") + row_labels = self._raw_row_labels + else: + row_labels = [f"Row {i+1}" for i in range(n_rows)] + else: + # 1D structure (like forest_plot) + structure_type = "1D" + dabest_objs_2d = [dabest_objs] # Wrap in single row for unified processing + n_rows = 1 + n_cols = len(dabest_objs) + + # Handle 1D labels + if labels: + if not isinstance(labels, (list, tuple)): + raise TypeError("labels must be a list for 1D dabest_objs") + if len(labels) != n_cols: + raise ValueError("Number of labels must match number of dabest_objs") + col_labels = labels + else: + col_labels = [f"Contrast {i+1}" for i in range(n_cols)] + row_labels = [""] # Single empty row label + + return { + 'type': structure_type, + 'dabest_objs_2d': dabest_objs_2d, + 'n_rows': n_rows, + 'n_cols': n_cols, + 'col_labels': col_labels, + 'row_labels': row_labels, + 'total_dabest_objs': n_rows * n_cols + } + + def _validate_contrast_consistency(self) -> Union[str, Dict]: + """ + Validate contrast consistency with support for mixed types in vortexmap. + + Returns either: + - str: Single contrast type for homogeneous data (forest_plot compatible) + - dict: Row-wise contrast types for mixed data (vortexmap only) + """ + all_dabest_objs = [] + for row in self.structure['dabest_objs_2d']: + all_dabest_objs.extend(row) + + if not all_dabest_objs: + raise ValueError("No valid dabest_objs found") + + # First, validate EACH contrast individually + for i, dabest_obj in enumerate(all_dabest_objs): + self._validate_individual_dabest_obj(dabest_obj, i) + + # Analyze contrast type structure + contrast_types_by_row = [] + for row_idx, row in enumerate(self.structure['dabest_objs_2d']): + row_types = [] + for contrast in row: + contrast_type = ("delta2" if contrast.delta2 + else "mini_meta" if contrast.is_mini_meta + else "delta") + row_types.append(contrast_type) + contrast_types_by_row.append(row_types) + + # Check if all dabest_objs are the same type (forest_plot requirement) + all_types_flat = [t for row_types in contrast_types_by_row for t in row_types] + unique_types = set(all_types_flat) + + if len(unique_types) == 1: + # Homogeneous: all same type (forest_plot compatible) + contrast_type = list(unique_types)[0] + self._validate_effect_size_compatibility(contrast_type) + return contrast_type + + else: + # Heterogeneous: mixed types (vortexmap only) + if self.structure['type'] == '1D': + raise ValueError( + "Mixed contrast types are only supported for 2D structures (vortexmaps). " + f"Found types: {unique_types}. For forest plots, all dabest_objs must be the same type." + ) + + # Validate within-row consistency for vortexmap + for row_idx, row_types in enumerate(contrast_types_by_row): + unique_row_types = set(row_types) + if len(unique_row_types) > 1: + raise ValueError( + f"Within each row, all dabest_objs must be the same type. " + f"Row {row_idx} has mixed types: {unique_row_types}" + ) + + # Validate effect size compatibility for each row type + for row_types in contrast_types_by_row: + row_type = row_types[0] # All same within row + self._validate_effect_size_compatibility(row_type) + + # Return row-wise type information + return { + 'mixed': True, + 'by_row': [row_types[0] for row_types in contrast_types_by_row], + 'unique_types': list(unique_types) + } + + def _validate_effect_size_compatibility(self, contrast_type: str): + """Validate effect size compatibility with a specific contrast type.""" + if contrast_type == "mini_meta" and self.effect_size != 'mean_diff': + raise ValueError("effect_size must be 'mean_diff' for mini-meta analyses") + + if contrast_type == "delta2" and self.effect_size not in ['mean_diff', 'hedges_g', 'delta_g']: + raise ValueError( + "effect_size must be 'mean_diff', 'hedges_g', or 'delta_g' for delta-delta analyses" + ) + + def _validate_individual_dabest_obj(self, dabest_obj, position: int): + """ + Validate individual dabest object. + + Parameters + ---------- + dabest_obj : object + Individual dabest object to validate + position : int + Position in the contrast list for error reporting + """ + # Basic existence check + if dabest_obj is None: + raise ValueError(f"Dabest object at position {position} is None") + + # Required attributes for dabest objects + required_attrs = ['delta2', 'is_mini_meta'] + for attr in required_attrs: + if not hasattr(dabest_obj, attr): + raise TypeError( + f"Object at position {position} is not a valid dabest object. " + f"Missing required attribute: '{attr}'" + ) + + # Validate effect size attribute exists + effect_attr = "hedges_g" if self.effect_size == 'delta_g' else self.effect_size + if not hasattr(dabest_obj, effect_attr): + raise AttributeError( + f"Dabest Object at position {position} does not have effect size '{self.effect_size}'. " + f"Expected attribute: '{effect_attr}'" + ) + + # Test that we can actually access the effect size data + try: + effect_obj = getattr(dabest_obj, effect_attr) + + # For delta2/mini_meta, check the nested attributes exist + if dabest_obj.delta2: + if not hasattr(effect_obj, 'delta_delta'): + raise AttributeError(f"Delta-delta contrast at position {position} missing 'delta_delta' attribute") + elif dabest_obj.is_mini_meta: + if not hasattr(effect_obj, 'mini_meta'): + raise AttributeError(f"Mini-meta contrast at position {position} missing 'mini_meta' attribute") + else: + # Standard contrast - check results structure + if not hasattr(effect_obj, 'results'): + raise AttributeError(f"Standard contrast at position {position} missing 'results' attribute") + except Exception as e: + raise ValueError( + f"Failed to access effect size data for dabest object at position {position}: {str(e)}" + ) + + def _extract_data(self) -> Tuple[List, List, List, List]: + """ + Extract bootstrap, effect sizes, and CI data. + Handles mixed contrast types for vortexmap. + """ + if self._bootstrap_data is not None: + return self._bootstrap_data, self._effect_data, self._ci_data + + # Process effect size attribute name + effect_attr = "hedges_g" if self.effect_size == 'delta_g' else self.effect_size + + bootstraps = [] + differences = [] + ci_lows = [] + ci_highs = [] + + if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'): + # Mixed types: process row by row + for row_idx, row in enumerate(self.structure['dabest_objs_2d']): + row_contrast_type = self.contrast_type['by_row'][row_idx] + contrast_attr = {"delta2": "delta_delta", "mini_meta": "mini_meta"}.get(row_contrast_type) + + for contrast in row: + bootstrap, diff, ci_low, ci_high = self._extract_single_contrast( + contrast, effect_attr, row_contrast_type, contrast_attr + ) + bootstraps.extend(bootstrap if isinstance(bootstrap, list) else [bootstrap]) + differences.extend(diff if isinstance(diff, list) else [diff]) + ci_lows.extend(ci_low if isinstance(ci_low, list) else [ci_low]) + ci_highs.extend(ci_high if isinstance(ci_high, list) else [ci_high]) + + else: + # Homogeneous types: process all together (original logic) + contrast_attr = {"delta2": "delta_delta", "mini_meta": "mini_meta"}.get(self.contrast_type) + + all_dabest_objs = [] + for row in self.structure['dabest_objs_2d']: + all_dabest_objs.extend(row) + + for contrast in all_dabest_objs: + bootstrap, diff, ci_low, ci_high = self._extract_single_contrast( + contrast, effect_attr, self.contrast_type, contrast_attr + ) + bootstraps.extend(bootstrap if isinstance(bootstrap, list) else [bootstrap]) + differences.extend(diff if isinstance(diff, list) else [diff]) + ci_lows.extend(ci_low if isinstance(ci_low, list) else [ci_low]) + ci_highs.extend(ci_high if isinstance(ci_high, list) else [ci_high]) + + # Cache results + self._bootstrap_data = bootstraps + self._effect_data = differences + self._ci_data = (ci_lows, ci_highs) + + return bootstraps, differences, ci_lows, ci_highs + + def _extract_single_contrast(self, contrast, effect_attr, contrast_type, contrast_attr): + """Extract data from a single contrast object.""" + if contrast_type == 'delta': + # Standard dabest_objs - may have multiple comparisons + effect_obj = getattr(contrast, effect_attr) + boot_list = effect_obj.results.bootstraps.to_list() + diff_list = effect_obj.results.difference.to_list() + low_list = effect_obj.results.get(f'{self.ci_type}_low').to_list() + high_list = effect_obj.results.get(f'{self.ci_type}_high').to_list() + return boot_list, diff_list, low_list, high_list + + else: + # Delta-delta or mini-meta - single value per contrast + effect_obj = getattr(contrast, effect_attr) + processed_obj = getattr(effect_obj, contrast_attr) + + if contrast_type == "delta2": + bootstrap = processed_obj.bootstraps_delta_delta + difference = processed_obj.difference + else: # mini_meta + bootstrap = processed_obj.bootstraps_weighted_delta + difference = processed_obj.difference + + ci_low = processed_obj.results.get(f'{self.ci_type}_low')[0] + ci_high = processed_obj.results.get(f'{self.ci_type}_high')[0] + + return bootstrap, difference, ci_low, ci_high + @property + def bootstraps(self) -> List: + """Get bootstrap samples for all dabest_objs.""" + bootstraps, _, _, _ = self._extract_data() + return bootstraps + + @property + def effect_sizes(self) -> List: + """Get effect sizes for all dabest_objs.""" + _, effects, _, _ = self._extract_data() + return effects + + @property + def confidence_intervals(self) -> Tuple[List, List]: + """Get confidence interval bounds.""" + _, _, ci_lows, ci_highs = self._extract_data() + return ci_lows, ci_highs + + def forest_plot(self, **kwargs): + """ + Create forest plot using validated data. + + This is a convenience method that calls the existing forest_plot function + with validated dabest objects. # TODO: decide whether to + migrate forest_plot to use MultiContrast data directly. + """ + # Check compatibility with forest plot (mixed contrast types not supported) + if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'): + raise ValueError( + "Forest plots require all dabest_objs to be the same type. " + f"This MultiContrast has mixed types: {self.contrast_type['unique_types']}. " + "Consider creating separate MultiContrast objects for each type, " + "or use vortexmap() which supports mixed types." + ) + + # Import forest_plot function + from .forest_plot import forest_plot + + # Get flattened contrast list for existing forest_plot function + all_dabest_objs = [] + for row in self.structure['dabest_objs_2d']: + all_dabest_objs.extend(row) + + # Set default parameters, allow kwargs to override + forest_kwargs = { + 'effect_size': self.effect_size, + 'ci_type': self.ci_type, + 'labels': self.structure['col_labels'], + } + forest_kwargs.update(kwargs) # kwargs can override defaults + + # Call existing forest_plot with validated dabest objects + return forest_plot(data=all_dabest_objs, **forest_kwargs) + + def vortexmap(self, **kwargs): + """ + Create vortexmap using validated data. + + This uses the enhanced vortexmap that can handle both homogeneous + and mixed contrast types. + """ + # Import here to avoid circular imports + from .multi import vortexmap + + # Call enhanced vortexmap with self as the multi_contrast object + return vortexmap(multi_contrast=self, **kwargs) + def get_bootstrap_by_position(self, row: int, col: int): + """ + Get bootstrap data for a specific position in the grid. + Useful for mixed-type vortexmaps. + """ + if row >= self.structure['n_rows'] or col >= self.structure['n_cols']: + raise IndexError(f"Position ({row}, {col}) out of bounds for {self.structure['n_rows']}×{self.structure['n_cols']} grid") + + contrast = self.structure['dabest_objs_2d'][row][col] + effect_attr = "hedges_g" if self.effect_size == 'delta_g' else self.effect_size + + # Determine contrast type for this position + if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'): + position_type = self.contrast_type['by_row'][row] + else: + position_type = self.contrast_type + + contrast_attr = {"delta2": "delta_delta", "mini_meta": "mini_meta"}.get(position_type) + + # Extract bootstrap for this specific contrast + bootstrap, _, _, _ = self._extract_single_contrast(contrast, effect_attr, position_type, contrast_attr) + + # For standard dabest_objs, return first bootstrap (they may have multiple) + if isinstance(bootstrap, list) and len(bootstrap) > 0: + return bootstrap[0] + return bootstrap + + def __repr__(self): + if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'): + types_info = f"mixed({', '.join(self.contrast_type['unique_types'])})" + else: + types_info = self.contrast_type + + return (f"MultiContrast({self.structure['type']}: " + f"{self.structure['n_rows']}x{self.structure['n_cols']}, " + f"effect_size='{self.effect_size}', " + f"contrast_type='{types_info}')") + +# %% ../nbs/API/multi.ipynb 8 +def combine(dabest_objs: Union[List, List[List]], + labels: Optional[List[str]] = None, + row_labels: Optional[List[str]] = None, + effect_size: str = "mean_diff", + ci_type: str = "bca", + allow_mixed_types: bool = False) -> MultiContrast: + """ + Create a MultiContrast object from raw dabest objects. + + This is the main entry point that users should use to create + multi-contrast visualizations. + + Parameters + ---------- + dabest_objs : Union[List, List[List]] + Raw dabest objects in 1D or 2D structure + labels : Optional[Union[List[str], List[List[str]]]], default=None + Labels for dabest_objs + effect_size : str, default="mean_diff" + Effect size to extract + ci_type : str, default="bca" + Confidence interval type + allow_mixed_types : bool, default=False + If True, allows different contrast types in different rows (vortexmap only) + If False, enforces homogeneous types (forest_plot compatible) + + Returns + ------- + MultiContrast + Validated multi-contrast object ready for visualization + + Examples + -------- + # Homogeneous 1D structure (forest_plot and vortexmap compatible) + mc = combine([dabest1, dabest2, dabest3], + labels=['Treatment A', 'Treatment B', 'Treatment C']) + mc.forest_plot() + mc.vortexmap() # Will arrange in single row + + # Homogeneous 2D structure (forest_plot flattens, vortexmap uses grid) + mc = combine([[dabest1, dabest2], [dabest3, dabest4]], + labels=[['Dose Low', 'Dose High'], ['Time 1', 'Time 2']]) + mc.vortexmap() # 2x2 grid + mc.forest_plot() # Flattened to 1D + + # Mixed types 2D structure (vortexmap only!) + mc = combine([[standard_dabest1, standard_dabest2], + [delta2_dabest1, delta2_dabest2]], + labels=[['Standard A', 'Standard B'], + ['Delta2 A', 'Delta2 B']], + allow_mixed_types=True) + mc.vortexmap() # Works: mixed spiral types per row + # mc.forest_plot() # Raises error: incompatible with mixed types + + # Mini-meta + Delta2 mixed example + mc = combine([[mini_meta1, mini_meta2], + [delta2_obj1, delta2_obj2]], + allow_mixed_types=True) + mc.vortexmap() # Top row: mini-meta spirals, bottom row: delta2 spirals + """ + mc = MultiContrast(dabest_objs, labels, row_labels, effect_size, ci_type) + + # Check mixed types policy + if isinstance(mc.contrast_type, dict) and mc.contrast_type.get('mixed'): + if not allow_mixed_types: + raise ValueError( + f"Mixed contrast types detected: {mc.contrast_type['unique_types']}. " + "Set allow_mixed_types=True to enable mixed-type vortexmaps, " + "or ensure all dabest_objs are the same type for forest_plot compatibility." + ) + + return mc + +# %% ../nbs/API/multi.ipynb 10 +def _sample_bootstrap(bootstrap, m, n, reverse_neg, abs_rank, chop_tail): + """Sample bootstrap values and prepare for spiral visualization.""" + bootstrap_sorted = sorted(bootstrap) + chop_tail_int = int(np.ceil(len(bootstrap_sorted) * chop_tail / 100)) + bootstrap_sorted = bootstrap_sorted[chop_tail_int : len(bootstrap_sorted) - chop_tail_int] + + ranks_to_look = np.linspace(0, len(bootstrap_sorted), m * n, dtype=int) + ranks_to_look[0] = 1 + + if np.sum(np.array(bootstrap_sorted) > 0) < len(bootstrap_sorted) / 2: + if reverse_neg: + bootstrap_sorted = bootstrap_sorted[::-1] + + if abs_rank: + bootstrap_sorted = sorted(bootstrap_sorted, key=abs) + + long_ranks = [bootstrap_sorted[r - 1] for r in ranks_to_look] + return long_ranks + +# %% ../nbs/API/multi.ipynb 11 +def _spiralize(fill, m, n): + """Convert linear array into spiral pattern.""" + i = 0 + j = 0 + k = 0 + array = np.zeros((m, n)) + + while m > 0 and k < len(fill): + jj = j + ii = i + + # Right + for j in range(j, n): + if k >= len(fill): + break + array[i, j] = fill[k] + k += 1 + + # Down + for i in range(ii + 1, m): + if k >= len(fill): + break + array[i, j] = fill[k] + k += 1 + + # Left + for j in range(n - 2, jj - 1, -1): + if k >= len(fill): + break + array[i, j] = fill[k] + k += 1 + + # Up + for i in range(m - 2, ii, -1): + if k >= len(fill): + break + array[i, j] = fill[k] + k += 1 + + m -= 1 + n -= 1 + j += 1 + + return array + +# %% ../nbs/API/multi.ipynb 12 +def vortexmap(multi_contrast, n=21, sort_by=None, cmap = 'vlag', vmax = None, vmin = None, + reverse_neg=True, abs_rank=False, chop_tail=0, ax=None,fig_size=None, **kwargs): + """ + Create a vortexmap visualization of multiple contrasts. + + Parameters + ---------- + multi_contrast : MultiContrast + Object containing multiple dabest objects + n : int, default 21 + Size of each spiral (n x n grid per contrast) + sort_by : list, optional + Order to sort contrasts by + vmax, vmin : float, default None, None + Color scale limits + reverse_neg : bool, default True + Whether to reverse negative values + abs_rank : bool, default False + Whether to rank by absolute value + chop_tail : float, default 0 + Percentage of extreme values to exclude + ax : matplotlib.Axes, optional + Existing axes to plot on + + Returns + ------- + tuple + (figure, axes, mean_delta_dataframe) if ax is None, + else (axes, mean_delta_dataframe) + """ + structure = multi_contrast.structure + + n_rows = structure['n_rows'] + n_cols = structure['n_cols'] + col_labels = structure['col_labels'] + row_labels = structure['row_labels'] + was_1d = (structure['type'] == '1D') + + # Initialize spirals and mean_delta DataFrames + spirals = pd.DataFrame(np.zeros((n_rows * n, n_cols * n))) + + mean_delta = pd.DataFrame(np.zeros((n_rows, n_cols)), + columns=col_labels, + index=row_labels) + # Get all bootstrap data from MultiContrast + all_bootstraps = multi_contrast.bootstraps + bootstrap_idx = 0 + + for i in range(n_rows): + for j in range(n_cols): + contrast_idx = sort_by[j] if sort_by is not None else j + + # For mixed types, get bootstrap for specific position + if isinstance(multi_contrast.contrast_type, dict) and multi_contrast.contrast_type.get('mixed'): + bootstrap = multi_contrast.get_bootstrap_by_position(i, contrast_idx) + else: + # For homogeneous types, use the flattened bootstrap list + flat_idx = i * n_cols + contrast_idx + if flat_idx < len(all_bootstraps): + bootstrap = all_bootstraps[flat_idx] + else: + # Handle case where we have fewer bootstraps than expected + bootstrap = all_bootstraps[bootstrap_idx] + bootstrap_idx += 1 + + long_ranks = _sample_bootstrap(bootstrap, n, n, reverse_neg, abs_rank, chop_tail) + spiral = _spiralize(long_ranks, n, n) + spirals.iloc[i*n:i*n+n, j*n:j*n+n] = spiral + mean_delta.iloc[i, j] = np.mean(long_ranks) + + if ax is None: + f, a = plt.subplots(1, 1) + else: + a = ax + if vmax is None: + vmax = np.max(spirals.values) + if vmin is None: + vmin = np.min(spirals.values) + if was_1d: + cbar_orientation = 'horizontal' + cbar_location = 'top' + else: + cbar_orientation = 'vertical' + cbar_location = 'right' + + # Create heatmap + sns.heatmap(spirals, cmap=cmap, cbar_kws={"shrink": 1, "pad": .17, "orientation": cbar_orientation, "location": cbar_location}, + ax=a, center = 0, vmax=vmax, vmin=vmin, **kwargs) + + # Set labels + a.set_xticks(np.linspace(n/2, n_cols*n-n/2, n_cols)) + a.set_xticklabels(col_labels, rotation=45, ha='right') + + if was_1d: + a.set_xlabel('Contrasts') + a.set_ylabel(' ') + a.set_yticks([]) + a.set_yticklabels([]) + else: + a.set_yticks(np.linspace(n/2, n_rows*n-n/2, n_rows)) + a.set_yticklabels(row_labels, ha='right', rotation=0) + + if ax is None: + f.gca().set_aspect('equal') + if fig_size is None: + f.set_size_inches(n_cols/3, n_rows/3) + else: + f.set_size_inches(fig_size) + return f, a, mean_delta + else: + return a, mean_delta + + + +# %% ../nbs/API/multi.ipynb 13 +__all__ = ['MultiContrast', 'combine', 'vortexmap'] + diff --git a/nbs/API/multi.ipynb b/nbs/API/multi.ipynb new file mode 100644 index 00000000..51d5bf9a --- /dev/null +++ b/nbs/API/multi.ipynb @@ -0,0 +1,858 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "11740caf", + "metadata": {}, + "source": [ + "# multi\n", + "\n", + "In nbs/API/multi.ipynb\n", + "\n", + "This module provides functionality for visualizing multiple DABEST contrast objects simultaneously using advanced visualization techniques like vortexmaps and forest plots.\n", + "- order: 11" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "518492d2", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp multi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbcc3115", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "from nbdev.showdoc import *\n", + "import nbdev\n", + "nbdev.nbdev_export()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80099a4b", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "from typing import List, Optional, Union, Tuple, Dict, Any\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "316ebd45", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "985e0e49", + "metadata": {}, + "source": [ + "## MultiContrast Class\n", + "\n", + "The `MultiContrast` class enables visualization of multiple contrast objects in grid-based layouts.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4b58920", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class MultiContrast:\n", + " \"\"\"\n", + " Unified multiple contrast object for forest plots and vortexmaps.\n", + " \n", + " Takes raw dabest objects and provides validated, processed data\n", + " for downstream visualizations.\n", + " \"\"\"\n", + " \n", + " def __init__(self, \n", + " dabest_objs: Union[List, List[List]], \n", + " labels: Optional[List[str]] = None,\n", + " row_labels: Optional[List[str]] = None,\n", + " effect_size: str = \"mean_diff\",\n", + " ci_type: str = \"bca\"):\n", + " \"\"\"\n", + " Initialize MultiContrast object with checking.\n", + " \n", + " Parameters\n", + " ----------\n", + " dabest_objs : Union[List, List[List]]\n", + " Raw dabest objects. Can be:\n", + " - 1D: [dabest_obj1, dabest_obj2, ...] \n", + " - 2D: [[dabest_obj1, dabest_obj2], [dabest_obj3, dabest_obj4]]\n", + " labels : Optional[Union[List[str], List[List[str]]]], default=None\n", + " Labels matching the contrast array structure. If None, defaults will be generated.\n", + " effect_size : str, default=\"mean_diff\"\n", + " Effect size to extract from dabest objects\n", + " ci_type : str, default=\"bca\"\n", + " Confidence interval type\n", + " \"\"\"\n", + " # Store raw inputs for validation\n", + " self._raw_dabest_objs = dabest_objs\n", + " self._raw_labels = labels\n", + " self._raw_row_labels = row_labels \n", + "\n", + " # Validate and process inputs\n", + " self.effect_size = self._validate_effect_size(effect_size)\n", + " self.ci_type = self._validate_ci_type(ci_type)\n", + "\n", + " # Process structure (adapts forest_plot logic to handle 2D)\n", + " self.structure = self._validate_and_parse_structure(dabest_objs, labels)\n", + "\n", + " # Validate all dabest objects consistency\n", + " self.contrast_type = self._validate_contrast_consistency()\n", + "\n", + " # Extract data (adapts forest_plot's load_plot_data logic)\n", + " self._bootstrap_data = None\n", + " self._effect_size_data = None\n", + " self._ci_data = None\n", + " \n", + " def _validate_effect_size(self, effect_size: str) -> str:\n", + " \"\"\"Validate effect size parameter (from forest_plot).\"\"\"\n", + " possible_effect_sizes = [\n", + " 'mean_diff', 'median_diff', 'cohens_d', \n", + " 'cohens_h', 'cliffs_delta', 'hedges_g', 'delta_g'\n", + " ]\n", + " \n", + " if not isinstance(effect_size, str) or effect_size not in possible_effect_sizes:\n", + " raise TypeError(\n", + " f\"effect_size must be one of: {possible_effect_sizes}\"\n", + " )\n", + " return effect_size\n", + "\n", + " def _validate_ci_type(self, ci_type: str) -> str:\n", + " \"\"\"Validate CI type parameter (from forest_plot).\"\"\"\n", + " if ci_type not in ('bca', 'pct'):\n", + " raise TypeError(\"ci_type must be either 'bca' or 'pct'\")\n", + " return ci_type\n", + " \n", + " def _validate_and_parse_structure(self, dabest_objs, labels):\n", + " \"\"\"\n", + " Validate and parse contrast structure, combining forest_plot \n", + " validation with vortexmap's 2D handling.\n", + " \"\"\"\n", + " # Basic validation (from forest_plot)\n", + " if not isinstance(dabest_objs, (list, tuple)) or len(dabest_objs) == 0:\n", + " raise ValueError(\"dabest_objs must be a non-empty list\")\n", + " \n", + " # Determine if 1D or 2D structure\n", + " if isinstance(dabest_objs[0], (list, tuple)):\n", + " # 2D structure (can be used to plot vortexmap or a stack of forest plots)\n", + " structure_type = \"2D\"\n", + " dabest_objs_2d = dabest_objs\n", + " n_rows = len(dabest_objs)\n", + " n_cols = len(dabest_objs[0])\n", + " \n", + " # Validate rectangular structure\n", + " for i, row in enumerate(dabest_objs):\n", + " if not isinstance(row, (list, tuple)):\n", + " raise TypeError(f\"Row {i} must be a list/tuple in 2D structure\")\n", + " if len(row) != n_cols:\n", + " raise ValueError(\"All rows must have the same number of dabest_objs\")\n", + " \n", + " # Handle 2D labels\n", + " if labels:\n", + " if not isinstance(labels, (list, tuple)):\n", + " raise TypeError(\"labels must be a list for 2D dabest_objs\")\n", + " if len(labels) != n_cols:\n", + " raise ValueError(\"Number of labels must match number of columns of dabest_objs\")\n", + " col_labels = labels\n", + " else:\n", + " col_labels = [f\"Contrast {i+1}\" for i in range(n_cols)]\n", + " # Handle row_labels - use self._raw_row_labels if available\n", + " if hasattr(self, '_raw_row_labels') and self._raw_row_labels:\n", + " if not isinstance(self._raw_row_labels, (list, tuple)):\n", + " raise TypeError(\"row_labels must be a list for 2D dabest_objs\")\n", + " if len(self._raw_row_labels) != n_rows:\n", + " raise ValueError(\"Number of row_labels must match number of rows of dabest_objs\")\n", + " row_labels = self._raw_row_labels\n", + " else:\n", + " row_labels = [f\"Row {i+1}\" for i in range(n_rows)]\n", + " else:\n", + " # 1D structure (like forest_plot)\n", + " structure_type = \"1D\"\n", + " dabest_objs_2d = [dabest_objs] # Wrap in single row for unified processing\n", + " n_rows = 1\n", + " n_cols = len(dabest_objs)\n", + " \n", + " # Handle 1D labels\n", + " if labels:\n", + " if not isinstance(labels, (list, tuple)):\n", + " raise TypeError(\"labels must be a list for 1D dabest_objs\")\n", + " if len(labels) != n_cols:\n", + " raise ValueError(\"Number of labels must match number of dabest_objs\")\n", + " col_labels = labels\n", + " else:\n", + " col_labels = [f\"Contrast {i+1}\" for i in range(n_cols)]\n", + " row_labels = [\"\"] # Single empty row label\n", + " \n", + " return {\n", + " 'type': structure_type,\n", + " 'dabest_objs_2d': dabest_objs_2d,\n", + " 'n_rows': n_rows,\n", + " 'n_cols': n_cols,\n", + " 'col_labels': col_labels,\n", + " 'row_labels': row_labels,\n", + " 'total_dabest_objs': n_rows * n_cols\n", + " }\n", + " \n", + " def _validate_contrast_consistency(self) -> Union[str, Dict]:\n", + " \"\"\"\n", + " Validate contrast consistency with support for mixed types in vortexmap.\n", + " \n", + " Returns either:\n", + " - str: Single contrast type for homogeneous data (forest_plot compatible)\n", + " - dict: Row-wise contrast types for mixed data (vortexmap only)\n", + " \"\"\"\n", + " all_dabest_objs = []\n", + " for row in self.structure['dabest_objs_2d']:\n", + " all_dabest_objs.extend(row)\n", + " \n", + " if not all_dabest_objs:\n", + " raise ValueError(\"No valid dabest_objs found\")\n", + " \n", + " # First, validate EACH contrast individually\n", + " for i, dabest_obj in enumerate(all_dabest_objs):\n", + " self._validate_individual_dabest_obj(dabest_obj, i)\n", + " \n", + " # Analyze contrast type structure\n", + " contrast_types_by_row = []\n", + " for row_idx, row in enumerate(self.structure['dabest_objs_2d']):\n", + " row_types = []\n", + " for contrast in row:\n", + " contrast_type = (\"delta2\" if contrast.delta2 \n", + " else \"mini_meta\" if contrast.is_mini_meta\n", + " else \"delta\")\n", + " row_types.append(contrast_type)\n", + " contrast_types_by_row.append(row_types)\n", + " \n", + " # Check if all dabest_objs are the same type (forest_plot requirement)\n", + " all_types_flat = [t for row_types in contrast_types_by_row for t in row_types]\n", + " unique_types = set(all_types_flat)\n", + " \n", + " if len(unique_types) == 1:\n", + " # Homogeneous: all same type (forest_plot compatible)\n", + " contrast_type = list(unique_types)[0]\n", + " self._validate_effect_size_compatibility(contrast_type)\n", + " return contrast_type\n", + " \n", + " else:\n", + " # Heterogeneous: mixed types (vortexmap only)\n", + " if self.structure['type'] == '1D':\n", + " raise ValueError(\n", + " \"Mixed contrast types are only supported for 2D structures (vortexmaps). \"\n", + " f\"Found types: {unique_types}. For forest plots, all dabest_objs must be the same type.\"\n", + " )\n", + " \n", + " # Validate within-row consistency for vortexmap\n", + " for row_idx, row_types in enumerate(contrast_types_by_row):\n", + " unique_row_types = set(row_types)\n", + " if len(unique_row_types) > 1:\n", + " raise ValueError(\n", + " f\"Within each row, all dabest_objs must be the same type. \"\n", + " f\"Row {row_idx} has mixed types: {unique_row_types}\"\n", + " )\n", + " \n", + " # Validate effect size compatibility for each row type\n", + " for row_types in contrast_types_by_row:\n", + " row_type = row_types[0] # All same within row\n", + " self._validate_effect_size_compatibility(row_type)\n", + " \n", + " # Return row-wise type information\n", + " return {\n", + " 'mixed': True,\n", + " 'by_row': [row_types[0] for row_types in contrast_types_by_row],\n", + " 'unique_types': list(unique_types)\n", + " }\n", + " \n", + " def _validate_effect_size_compatibility(self, contrast_type: str):\n", + " \"\"\"Validate effect size compatibility with a specific contrast type.\"\"\"\n", + " if contrast_type == \"mini_meta\" and self.effect_size != 'mean_diff':\n", + " raise ValueError(\"effect_size must be 'mean_diff' for mini-meta analyses\")\n", + " \n", + " if contrast_type == \"delta2\" and self.effect_size not in ['mean_diff', 'hedges_g', 'delta_g']:\n", + " raise ValueError(\n", + " \"effect_size must be 'mean_diff', 'hedges_g', or 'delta_g' for delta-delta analyses\"\n", + " ) \n", + " \n", + " def _validate_individual_dabest_obj(self, dabest_obj, position: int):\n", + " \"\"\"\n", + " Validate individual dabest object.\n", + " \n", + " Parameters\n", + " ----------\n", + " dabest_obj : object\n", + " Individual dabest object to validate\n", + " position : int\n", + " Position in the contrast list for error reporting\n", + " \"\"\"\n", + " # Basic existence check\n", + " if dabest_obj is None:\n", + " raise ValueError(f\"Dabest object at position {position} is None\")\n", + " \n", + " # Required attributes for dabest objects\n", + " required_attrs = ['delta2', 'is_mini_meta']\n", + " for attr in required_attrs:\n", + " if not hasattr(dabest_obj, attr):\n", + " raise TypeError(\n", + " f\"Object at position {position} is not a valid dabest object. \"\n", + " f\"Missing required attribute: '{attr}'\"\n", + " )\n", + " \n", + " # Validate effect size attribute exists\n", + " effect_attr = \"hedges_g\" if self.effect_size == 'delta_g' else self.effect_size\n", + " if not hasattr(dabest_obj, effect_attr):\n", + " raise AttributeError(\n", + " f\"Dabest Object at position {position} does not have effect size '{self.effect_size}'. \"\n", + " f\"Expected attribute: '{effect_attr}'\"\n", + " )\n", + " \n", + " # Test that we can actually access the effect size data\n", + " try:\n", + " effect_obj = getattr(dabest_obj, effect_attr)\n", + "\n", + " # For delta2/mini_meta, check the nested attributes exist\n", + " if dabest_obj.delta2:\n", + " if not hasattr(effect_obj, 'delta_delta'):\n", + " raise AttributeError(f\"Delta-delta contrast at position {position} missing 'delta_delta' attribute\")\n", + " elif dabest_obj.is_mini_meta:\n", + " if not hasattr(effect_obj, 'mini_meta'):\n", + " raise AttributeError(f\"Mini-meta contrast at position {position} missing 'mini_meta' attribute\")\n", + " else:\n", + " # Standard contrast - check results structure\n", + " if not hasattr(effect_obj, 'results'):\n", + " raise AttributeError(f\"Standard contrast at position {position} missing 'results' attribute\") \n", + " except Exception as e:\n", + " raise ValueError(\n", + " f\"Failed to access effect size data for dabest object at position {position}: {str(e)}\"\n", + " )\n", + " \n", + " def _extract_data(self) -> Tuple[List, List, List, List]:\n", + " \"\"\"\n", + " Extract bootstrap, effect sizes, and CI data.\n", + " Handles mixed contrast types for vortexmap.\n", + " \"\"\"\n", + " if self._bootstrap_data is not None:\n", + " return self._bootstrap_data, self._effect_data, self._ci_data\n", + " \n", + " # Process effect size attribute name\n", + " effect_attr = \"hedges_g\" if self.effect_size == 'delta_g' else self.effect_size\n", + " \n", + " bootstraps = []\n", + " differences = []\n", + " ci_lows = []\n", + " ci_highs = []\n", + " \n", + " if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'):\n", + " # Mixed types: process row by row\n", + " for row_idx, row in enumerate(self.structure['dabest_objs_2d']):\n", + " row_contrast_type = self.contrast_type['by_row'][row_idx]\n", + " contrast_attr = {\"delta2\": \"delta_delta\", \"mini_meta\": \"mini_meta\"}.get(row_contrast_type)\n", + " \n", + " for contrast in row:\n", + " bootstrap, diff, ci_low, ci_high = self._extract_single_contrast(\n", + " contrast, effect_attr, row_contrast_type, contrast_attr\n", + " )\n", + " bootstraps.extend(bootstrap if isinstance(bootstrap, list) else [bootstrap])\n", + " differences.extend(diff if isinstance(diff, list) else [diff])\n", + " ci_lows.extend(ci_low if isinstance(ci_low, list) else [ci_low])\n", + " ci_highs.extend(ci_high if isinstance(ci_high, list) else [ci_high])\n", + " \n", + " else:\n", + " # Homogeneous types: process all together (original logic)\n", + " contrast_attr = {\"delta2\": \"delta_delta\", \"mini_meta\": \"mini_meta\"}.get(self.contrast_type)\n", + " \n", + " all_dabest_objs = []\n", + " for row in self.structure['dabest_objs_2d']:\n", + " all_dabest_objs.extend(row)\n", + " \n", + " for contrast in all_dabest_objs:\n", + " bootstrap, diff, ci_low, ci_high = self._extract_single_contrast(\n", + " contrast, effect_attr, self.contrast_type, contrast_attr\n", + " )\n", + " bootstraps.extend(bootstrap if isinstance(bootstrap, list) else [bootstrap])\n", + " differences.extend(diff if isinstance(diff, list) else [diff])\n", + " ci_lows.extend(ci_low if isinstance(ci_low, list) else [ci_low])\n", + " ci_highs.extend(ci_high if isinstance(ci_high, list) else [ci_high])\n", + " \n", + " # Cache results\n", + " self._bootstrap_data = bootstraps\n", + " self._effect_data = differences\n", + " self._ci_data = (ci_lows, ci_highs)\n", + " \n", + " return bootstraps, differences, ci_lows, ci_highs\n", + " \n", + " def _extract_single_contrast(self, contrast, effect_attr, contrast_type, contrast_attr):\n", + " \"\"\"Extract data from a single contrast object.\"\"\"\n", + " if contrast_type == 'delta':\n", + " # Standard dabest_objs - may have multiple comparisons\n", + " effect_obj = getattr(contrast, effect_attr)\n", + " boot_list = effect_obj.results.bootstraps.to_list()\n", + " diff_list = effect_obj.results.difference.to_list()\n", + " low_list = effect_obj.results.get(f'{self.ci_type}_low').to_list()\n", + " high_list = effect_obj.results.get(f'{self.ci_type}_high').to_list()\n", + " return boot_list, diff_list, low_list, high_list\n", + " \n", + " else:\n", + " # Delta-delta or mini-meta - single value per contrast\n", + " effect_obj = getattr(contrast, effect_attr)\n", + " processed_obj = getattr(effect_obj, contrast_attr)\n", + " \n", + " if contrast_type == \"delta2\":\n", + " bootstrap = processed_obj.bootstraps_delta_delta\n", + " difference = processed_obj.difference\n", + " else: # mini_meta\n", + " bootstrap = processed_obj.bootstraps_weighted_delta\n", + " difference = processed_obj.difference\n", + " \n", + " ci_low = processed_obj.results.get(f'{self.ci_type}_low')[0]\n", + " ci_high = processed_obj.results.get(f'{self.ci_type}_high')[0]\n", + " \n", + " return bootstrap, difference, ci_low, ci_high\n", + " @property \n", + " def bootstraps(self) -> List:\n", + " \"\"\"Get bootstrap samples for all dabest_objs.\"\"\"\n", + " bootstraps, _, _, _ = self._extract_data()\n", + " return bootstraps\n", + " \n", + " @property\n", + " def effect_sizes(self) -> List:\n", + " \"\"\"Get effect sizes for all dabest_objs.\"\"\"\n", + " _, effects, _, _ = self._extract_data()\n", + " return effects\n", + " \n", + " @property \n", + " def confidence_intervals(self) -> Tuple[List, List]:\n", + " \"\"\"Get confidence interval bounds.\"\"\"\n", + " _, _, ci_lows, ci_highs = self._extract_data()\n", + " return ci_lows, ci_highs\n", + " \n", + " def forest_plot(self, **kwargs):\n", + " \"\"\"\n", + " Create forest plot using validated data.\n", + " \n", + " This is a convenience method that calls the existing forest_plot function\n", + " with validated dabest objects. # TODO: decide whether to\n", + " migrate forest_plot to use MultiContrast data directly.\n", + " \"\"\"\n", + " # Check compatibility with forest plot (mixed contrast types not supported)\n", + " if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'):\n", + " raise ValueError(\n", + " \"Forest plots require all dabest_objs to be the same type. \"\n", + " f\"This MultiContrast has mixed types: {self.contrast_type['unique_types']}. \"\n", + " \"Consider creating separate MultiContrast objects for each type, \"\n", + " \"or use vortexmap() which supports mixed types.\"\n", + " )\n", + " \n", + " # Import forest_plot function\n", + " from .forest_plot import forest_plot\n", + " \n", + " # Get flattened contrast list for existing forest_plot function\n", + " all_dabest_objs = []\n", + " for row in self.structure['dabest_objs_2d']:\n", + " all_dabest_objs.extend(row)\n", + " \n", + " # Set default parameters, allow kwargs to override\n", + " forest_kwargs = {\n", + " 'effect_size': self.effect_size,\n", + " 'ci_type': self.ci_type,\n", + " 'labels': self.structure['col_labels'],\n", + " }\n", + " forest_kwargs.update(kwargs) # kwargs can override defaults\n", + " \n", + " # Call existing forest_plot with validated dabest objects\n", + " return forest_plot(data=all_dabest_objs, **forest_kwargs)\n", + "\n", + " def vortexmap(self, **kwargs):\n", + " \"\"\"\n", + " Create vortexmap using validated data.\n", + " \n", + " This uses the enhanced vortexmap that can handle both homogeneous\n", + " and mixed contrast types.\n", + " \"\"\"\n", + " # Import here to avoid circular imports \n", + " from .multi import vortexmap\n", + " \n", + " # Call enhanced vortexmap with self as the multi_contrast object\n", + " return vortexmap(multi_contrast=self, **kwargs) \n", + " def get_bootstrap_by_position(self, row: int, col: int):\n", + " \"\"\"\n", + " Get bootstrap data for a specific position in the grid.\n", + " Useful for mixed-type vortexmaps.\n", + " \"\"\"\n", + " if row >= self.structure['n_rows'] or col >= self.structure['n_cols']:\n", + " raise IndexError(f\"Position ({row}, {col}) out of bounds for {self.structure['n_rows']}×{self.structure['n_cols']} grid\")\n", + " \n", + " contrast = self.structure['dabest_objs_2d'][row][col]\n", + " effect_attr = \"hedges_g\" if self.effect_size == 'delta_g' else self.effect_size\n", + " \n", + " # Determine contrast type for this position\n", + " if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'):\n", + " position_type = self.contrast_type['by_row'][row]\n", + " else:\n", + " position_type = self.contrast_type\n", + " \n", + " contrast_attr = {\"delta2\": \"delta_delta\", \"mini_meta\": \"mini_meta\"}.get(position_type)\n", + " \n", + " # Extract bootstrap for this specific contrast\n", + " bootstrap, _, _, _ = self._extract_single_contrast(contrast, effect_attr, position_type, contrast_attr)\n", + " \n", + " # For standard dabest_objs, return first bootstrap (they may have multiple)\n", + " if isinstance(bootstrap, list) and len(bootstrap) > 0:\n", + " return bootstrap[0]\n", + " return bootstrap\n", + " \n", + " def __repr__(self):\n", + " if isinstance(self.contrast_type, dict) and self.contrast_type.get('mixed'):\n", + " types_info = f\"mixed({', '.join(self.contrast_type['unique_types'])})\"\n", + " else:\n", + " types_info = self.contrast_type\n", + " \n", + " return (f\"MultiContrast({self.structure['type']}: \"\n", + " f\"{self.structure['n_rows']}x{self.structure['n_cols']}, \"\n", + " f\"effect_size='{self.effect_size}', \"\n", + " f\"contrast_type='{types_info}')\") " + ] + }, + { + "cell_type": "markdown", + "id": "75517120", + "metadata": {}, + "source": [ + "## Loading Function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6952d49", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def combine(dabest_objs: Union[List, List[List]], \n", + " labels: Optional[List[str]] = None,\n", + " row_labels: Optional[List[str]] = None,\n", + " effect_size: str = \"mean_diff\",\n", + " ci_type: str = \"bca\",\n", + " allow_mixed_types: bool = False) -> MultiContrast:\n", + " \"\"\"\n", + " Create a MultiContrast object from raw dabest objects.\n", + " \n", + " This is the main entry point that users should use to create\n", + " multi-contrast visualizations.\n", + " \n", + " Parameters\n", + " ----------\n", + " dabest_objs : Union[List, List[List]]\n", + " Raw dabest objects in 1D or 2D structure\n", + " labels : Optional[Union[List[str], List[List[str]]]], default=None\n", + " Labels for dabest_objs\n", + " effect_size : str, default=\"mean_diff\" \n", + " Effect size to extract\n", + " ci_type : str, default=\"bca\"\n", + " Confidence interval type\n", + " allow_mixed_types : bool, default=False\n", + " If True, allows different contrast types in different rows (vortexmap only)\n", + " If False, enforces homogeneous types (forest_plot compatible)\n", + " \n", + " Returns\n", + " -------\n", + " MultiContrast\n", + " Validated multi-contrast object ready for visualization\n", + " \n", + " Examples\n", + " --------\n", + " # Homogeneous 1D structure (forest_plot and vortexmap compatible)\n", + " mc = combine([dabest1, dabest2, dabest3], \n", + " labels=['Treatment A', 'Treatment B', 'Treatment C'])\n", + " mc.forest_plot()\n", + " mc.vortexmap() # Will arrange in single row\n", + " \n", + " # Homogeneous 2D structure (forest_plot flattens, vortexmap uses grid)\n", + " mc = combine([[dabest1, dabest2], [dabest3, dabest4]], \n", + " labels=[['Dose Low', 'Dose High'], ['Time 1', 'Time 2']])\n", + " mc.vortexmap() # 2x2 grid\n", + " mc.forest_plot() # Flattened to 1D\n", + " \n", + " # Mixed types 2D structure (vortexmap only!)\n", + " mc = combine([[standard_dabest1, standard_dabest2], \n", + " [delta2_dabest1, delta2_dabest2]],\n", + " labels=[['Standard A', 'Standard B'], \n", + " ['Delta2 A', 'Delta2 B']],\n", + " allow_mixed_types=True)\n", + " mc.vortexmap() # Works: mixed spiral types per row\n", + " # mc.forest_plot() # Raises error: incompatible with mixed types\n", + " \n", + " # Mini-meta + Delta2 mixed example\n", + " mc = combine([[mini_meta1, mini_meta2], \n", + " [delta2_obj1, delta2_obj2]],\n", + " allow_mixed_types=True)\n", + " mc.vortexmap() # Top row: mini-meta spirals, bottom row: delta2 spirals\n", + " \"\"\"\n", + " mc = MultiContrast(dabest_objs, labels, row_labels, effect_size, ci_type)\n", + " \n", + " # Check mixed types policy\n", + " if isinstance(mc.contrast_type, dict) and mc.contrast_type.get('mixed'):\n", + " if not allow_mixed_types:\n", + " raise ValueError(\n", + " f\"Mixed contrast types detected: {mc.contrast_type['unique_types']}. \"\n", + " \"Set allow_mixed_types=True to enable mixed-type vortexmaps, \"\n", + " \"or ensure all dabest_objs are the same type for forest_plot compatibility.\"\n", + " )\n", + " \n", + " return mc" + ] + }, + { + "cell_type": "markdown", + "id": "3a1a62e8", + "metadata": {}, + "source": [ + "## Vortexmap Visualization\n", + "\n", + "The vortexmap creates spiral heatmaps showing the distribution of bootstrap samples for each contrast." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7814cc58", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def _sample_bootstrap(bootstrap, m, n, reverse_neg, abs_rank, chop_tail):\n", + " \"\"\"Sample bootstrap values and prepare for spiral visualization.\"\"\"\n", + " bootstrap_sorted = sorted(bootstrap)\n", + " chop_tail_int = int(np.ceil(len(bootstrap_sorted) * chop_tail / 100))\n", + " bootstrap_sorted = bootstrap_sorted[chop_tail_int : len(bootstrap_sorted) - chop_tail_int]\n", + " \n", + " ranks_to_look = np.linspace(0, len(bootstrap_sorted), m * n, dtype=int) \n", + " ranks_to_look[0] = 1\n", + " \n", + " if np.sum(np.array(bootstrap_sorted) > 0) < len(bootstrap_sorted) / 2:\n", + " if reverse_neg:\n", + " bootstrap_sorted = bootstrap_sorted[::-1]\n", + " \n", + " if abs_rank:\n", + " bootstrap_sorted = sorted(bootstrap_sorted, key=abs)\n", + " \n", + " long_ranks = [bootstrap_sorted[r - 1] for r in ranks_to_look]\n", + " return long_ranks" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "725c96b5", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def _spiralize(fill, m, n):\n", + " \"\"\"Convert linear array into spiral pattern.\"\"\"\n", + " i = 0\n", + " j = 0\n", + " k = 0\n", + " array = np.zeros((m, n))\n", + " \n", + " while m > 0 and k < len(fill):\n", + " jj = j\n", + " ii = i\n", + " \n", + " # Right\n", + " for j in range(j, n):\n", + " if k >= len(fill):\n", + " break\n", + " array[i, j] = fill[k]\n", + " k += 1\n", + " \n", + " # Down\n", + " for i in range(ii + 1, m):\n", + " if k >= len(fill):\n", + " break\n", + " array[i, j] = fill[k]\n", + " k += 1\n", + " \n", + " # Left\n", + " for j in range(n - 2, jj - 1, -1):\n", + " if k >= len(fill):\n", + " break\n", + " array[i, j] = fill[k]\n", + " k += 1\n", + " \n", + " # Up\n", + " for i in range(m - 2, ii, -1):\n", + " if k >= len(fill):\n", + " break\n", + " array[i, j] = fill[k]\n", + " k += 1\n", + " \n", + " m -= 1\n", + " n -= 1\n", + " j += 1\n", + " \n", + " return array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20809f1d", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def vortexmap(multi_contrast, n=21, sort_by=None, cmap = 'vlag', vmax = None, vmin = None, \n", + " reverse_neg=True, abs_rank=False, chop_tail=0, ax=None,fig_size=None, **kwargs):\n", + " \"\"\"\n", + " Create a vortexmap visualization of multiple contrasts.\n", + " \n", + " Parameters\n", + " ----------\n", + " multi_contrast : MultiContrast\n", + " Object containing multiple dabest objects\n", + " n : int, default 21\n", + " Size of each spiral (n x n grid per contrast)\n", + " sort_by : list, optional\n", + " Order to sort contrasts by\n", + " vmax, vmin : float, default None, None\n", + " Color scale limits\n", + " reverse_neg : bool, default True\n", + " Whether to reverse negative values\n", + " abs_rank : bool, default False\n", + " Whether to rank by absolute value\n", + " chop_tail : float, default 0\n", + " Percentage of extreme values to exclude\n", + " ax : matplotlib.Axes, optional\n", + " Existing axes to plot on\n", + " \n", + " Returns\n", + " -------\n", + " tuple\n", + " (figure, axes, mean_delta_dataframe) if ax is None, \n", + " else (axes, mean_delta_dataframe)\n", + " \"\"\"\n", + " structure = multi_contrast.structure\n", + "\n", + " n_rows = structure['n_rows']\n", + " n_cols = structure['n_cols']\n", + " col_labels = structure['col_labels']\n", + " row_labels = structure['row_labels']\n", + " was_1d = (structure['type'] == '1D')\n", + "\n", + " # Initialize spirals and mean_delta DataFrames\n", + " spirals = pd.DataFrame(np.zeros((n_rows * n, n_cols * n)))\n", + " \n", + " mean_delta = pd.DataFrame(np.zeros((n_rows, n_cols)), \n", + " columns=col_labels, \n", + " index=row_labels)\n", + " # Get all bootstrap data from MultiContrast\n", + " all_bootstraps = multi_contrast.bootstraps\n", + " bootstrap_idx = 0\n", + "\n", + " for i in range(n_rows):\n", + " for j in range(n_cols):\n", + " contrast_idx = sort_by[j] if sort_by is not None else j\n", + " \n", + " # For mixed types, get bootstrap for specific position\n", + " if isinstance(multi_contrast.contrast_type, dict) and multi_contrast.contrast_type.get('mixed'):\n", + " bootstrap = multi_contrast.get_bootstrap_by_position(i, contrast_idx)\n", + " else:\n", + " # For homogeneous types, use the flattened bootstrap list\n", + " flat_idx = i * n_cols + contrast_idx\n", + " if flat_idx < len(all_bootstraps):\n", + " bootstrap = all_bootstraps[flat_idx]\n", + " else:\n", + " # Handle case where we have fewer bootstraps than expected\n", + " bootstrap = all_bootstraps[bootstrap_idx]\n", + " bootstrap_idx += 1\n", + " \n", + " long_ranks = _sample_bootstrap(bootstrap, n, n, reverse_neg, abs_rank, chop_tail)\n", + " spiral = _spiralize(long_ranks, n, n)\n", + " spirals.iloc[i*n:i*n+n, j*n:j*n+n] = spiral\n", + " mean_delta.iloc[i, j] = np.mean(long_ranks)\n", + " \n", + " if ax is None:\n", + " f, a = plt.subplots(1, 1)\n", + " else:\n", + " a = ax\n", + " if vmax is None:\n", + " vmax = np.max(spirals.values)\n", + " if vmin is None:\n", + " vmin = np.min(spirals.values)\n", + " if was_1d:\n", + " cbar_orientation = 'horizontal'\n", + " cbar_location = 'top'\n", + " else:\n", + " cbar_orientation = 'vertical'\n", + " cbar_location = 'right'\n", + " \n", + " # Create heatmap\n", + " sns.heatmap(spirals, cmap=cmap, cbar_kws={\"shrink\": 1, \"pad\": .17, \"orientation\": cbar_orientation, \"location\": cbar_location}, \n", + " ax=a, center = 0, vmax=vmax, vmin=vmin, **kwargs)\n", + " \n", + " # Set labels\n", + " a.set_xticks(np.linspace(n/2, n_cols*n-n/2, n_cols))\n", + " a.set_xticklabels(col_labels, rotation=45, ha='right')\n", + "\n", + " if was_1d:\n", + " a.set_xlabel('Contrasts')\n", + " a.set_ylabel(' ')\n", + " a.set_yticks([])\n", + " a.set_yticklabels([])\n", + " else:\n", + " a.set_yticks(np.linspace(n/2, n_rows*n-n/2, n_rows))\n", + " a.set_yticklabels(row_labels, ha='right', rotation=0)\n", + "\n", + " if ax is None:\n", + " f.gca().set_aspect('equal')\n", + " if fig_size is None:\n", + " f.set_size_inches(n_cols/3, n_rows/3)\n", + " else:\n", + " f.set_size_inches(fig_size)\n", + " return f, a, mean_delta\n", + " else:\n", + " return a, mean_delta\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f23adcf", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "__all__ = ['MultiContrast', 'combine', 'vortexmap']\n" + ] + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/nbs/_quarto.yml b/nbs/_quarto.yml index bf368b27..6aacff28 100644 --- a/nbs/_quarto.yml +++ b/nbs/_quarto.yml @@ -17,6 +17,7 @@ website: contents: - auto: "/0*.ipynb" - auto: "tutorials/0*.ipynb" # Autogenerate a section of tutorial notebooks + - auto: "tutorials/1*.ipynb" # Autogenerate a section of tutorial notebooks - section: API contents: API/* favicon: images/Favicon-3-outline.svg diff --git a/nbs/tutorials/10-multicontrast.ipynb b/nbs/tutorials/10-multicontrast.ipynb new file mode 100644 index 00000000..0b7b6dd6 --- /dev/null +++ b/nbs/tutorials/10-multicontrast.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualizing Multiple Contrasts\n", + "\n", + "> Explanation of how to use forest_plot for contrast objects e.g delta-delta and mini-meta or regular deltas.\n", + "\n", + "- order: 11" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In DABEST **XXX**, we introduce two new ways of visualizing bootstrap distributions in more compact ways:\n", + "- forest plot\n", + "- vortexmap" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import norm\n", + "import dabest\n", + "from dabest.multi import combine, vortexmap" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a simulated dataset and generate a list of corresponding dabest objects" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def create_delta_dataset(N=20, \n", + " seed=9999, \n", + " second_quarter_adjustment=3, \n", + " third_quarter_adjustment=-0.1,\n", + " scale2=1, initial_loc = 3):\n", + " \"\"\"Create a sample dataset for delta-delta analysis.\"\"\"\n", + " np.random.seed(seed)\n", + "\n", + " # Create samples\n", + " y = norm.rvs(loc=initial_loc, scale=0.4, size=N*4)\n", + " y[N:2*N] = norm.rvs(loc=initial_loc + second_quarter_adjustment, scale=scale2, size=N) \n", + " y[2*N:3*N] = norm.rvs(loc=initial_loc + third_quarter_adjustment, scale=0.4, size=N)\n", + " y[3*N:4*N] = norm.rvs(loc=initial_loc, scale=0.4, size=N)\n", + "\n", + " # Treatment, Rep, Genotype, and ID columns\n", + " treatment = np.repeat(['Placebo', 'Drug'], N*2).tolist()\n", + " genotype = np.repeat(['W', 'M', 'W', 'M'], N).tolist()\n", + " id_col = list(range(0, N*2)) * 2\n", + "\n", + " # Combine all columns into a DataFrame\n", + " df = pd.DataFrame({\n", + " 'ID': id_col,\n", + " 'Genotype': genotype,\n", + " 'Treatment': treatment,\n", + " 'Tumor Size': y\n", + " })\n", + "\n", + " return df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Working with many many Dabest objects\n", + "Let's say you have a transcriptomics experiment where you investigate the effects of altering 6 genes on transcripts 1 to 10. You may simulate the data as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dabest_objects_2d = [[None for _ in range(10)] for _ in range(6)]\n", + "labels_2d = [\"Tx 1\", \"Tx2\", \"Tx3\", \"Tx4\", \"Tx5\", \"Tx6\", \"Tx7\", \"Tx8\", \"Tx9\" , \"Tx10\"]\n", + "row_labels_2d = [\"Geno A\", \"Geno B\", \"Geno C\", \"Geno D\", \"Geno E\", \"Geno F\"]\n", + "second_quarter_adjustment_2d = [[.9, 0, 1, .5, 1.2, -1, 0,0, 0, .4], \n", + " [1, 0, 2, 1, 1, -1, 0,0, 1.5, .4],\n", + " [1, 0, 1, 2, 1, 3, .5,0, -1.2, .4],\n", + " [1.1, 0, 2, 1, 1.4, -0.5, 0,1.1, 3, .4],\n", + " [1, 0, 2, 1.5, -1, -0.5, 0,0, 1, .4],\n", + " [-.3, 0, 2, .7, 1, -0.5, 0,0, 2.3, -.4],\n", + " ]\n", + "scale2_2d = [[1, 10, 1, 1000, 1, 2, 1,1, 0, .4], \n", + " [1, 0, 8, 3, 1, 4, 7,1, 1000, 2],\n", + " [15, 3, 1, 2, 1, 1, 90,1, 7, 2],\n", + " [1, 0, 1, 330, 1, 6,1,1, 3, .4],\n", + " [90, 0, 700, 1, 1, 2,1,1, 90, .4],\n", + " [1, 0, 1, 4, 1, 4,1,1, 3, .4],\n", + " ]\n", + "seeds = [1, 1000, 20, 9999, 109, 5320]\n", + "\n", + "for i in range(len(row_labels_2d)):\n", + " for j in range(len(labels_2d)):\n", + " df = create_delta_dataset(seed=seeds[i], \n", + " second_quarter_adjustment=second_quarter_adjustment_2d[i][j],\n", + " third_quarter_adjustment=-0.1, \n", + " initial_loc = 0)\n", + " dabest_objects_2d[i][j] = dabest.load(data=df, \n", + " x=[\"Genotype\", \"Genotype\"], \n", + " y=\"Tumor Size\", \n", + " delta2=True, \n", + " experiment=\"Treatment\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For later demo, we are going to create a new object called MultiContrast." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Applications/anaconda3/envs/vortexmap/lib/python3.10/site-packages/dabest/_effsize_objects.py:306: UserWarning: The lower limit of the interval was in the bottom 10 values. The result should be considered unstable.\n", + " warnings.warn(\n", + "/Applications/anaconda3/envs/vortexmap/lib/python3.10/site-packages/dabest/_effsize_objects.py:306: UserWarning: The lower limit of the interval was in the bottom 10 values. The result should be considered unstable.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MultiContrast(2D: 6x10, effect_size='hedges_g', contrast_type='delta2')\n" + ] + } + ], + "source": [ + "multi_2d = combine(dabest_objects_2d, labels_2d, row_labels=row_labels_2d, effect_size=\"hedges_g\")\n", + "print(multi_2d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This data would require stacks of forest plots to visualize." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "multiforest, axes = plt.subplots(6, 1, figsize=(8, 30))\n", + "for i in range(6):\n", + " multi_1d = combine(dabest_objects_2d[i], labels_2d, effect_size=\"hedges_g\")\n", + " fig_forest = multi_1d.forest_plot(\n", + " effect_size=\"mean_diff\",\n", + " ci_type=\"bca\", labels = labels_2d, ax = axes[i]\n", + " )\n", + " axes[i].set_title(row_labels_2d[i])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " So instead, we plot a vortexmap for a concise representation: Multicontrast objects present advantages especially when it comes to 2-D arrays of dabest objects. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "fig, ax, mean_delta = vortexmap(\n", + " multi_2d,\n", + " n=21, # Larger spiral size\n", + " vmax=None, vmin=None, # Extended color range\n", + " reverse_neg=True,\n", + " abs_rank=False,\n", + " chop_tail=5, # Remove 5% extreme values\n", + " fig_size = (10, 4)\n", + ")\n", + "plt.title(\"Gene Expression Vortexmap\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MultiContrast object can also handle 1-D dabest object arrays" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MultiContrast(1D: 1x5, effect_size='mean_diff', contrast_type='delta2')\n" + ] + } + ], + "source": [ + "df_drug1 = create_delta_dataset(seed=9999, second_quarter_adjustment=1, third_quarter_adjustment=-0.5)\n", + "df_drug2 = create_delta_dataset(seed=9999, second_quarter_adjustment=0.1, third_quarter_adjustment=-1)\n", + "df_drug3 = create_delta_dataset(seed=9999, second_quarter_adjustment=2, third_quarter_adjustment=-0.5)\n", + "df_drug4 = create_delta_dataset(seed=9999, second_quarter_adjustment=1, third_quarter_adjustment=-0.1, scale2=7)\n", + "df_drug5 = create_delta_dataset(seed=9999, second_quarter_adjustment=0.1, third_quarter_adjustment=-0.3, scale2=7)\n", + "\n", + "dabest_obj1 = dabest.load(data=df_drug1, \n", + " x=[\"Genotype\", \"Genotype\"], \n", + " y=\"Tumor Size\", \n", + " delta2=True, \n", + " experiment=\"Treatment\")\n", + "\n", + "dabest_obj2 = dabest.load(data=df_drug2, \n", + " x=[\"Genotype\", \"Genotype\"], \n", + " y=\"Tumor Size\", \n", + " delta2=True, \n", + " experiment=\"Treatment\")\n", + "\n", + "dabest_obj3 = dabest.load(data=df_drug3, \n", + " x=[\"Genotype\", \"Genotype\"], \n", + " y=\"Tumor Size\", \n", + " delta2=True, \n", + " experiment=\"Treatment\")\n", + "\n", + "dabest_obj4 = dabest.load(data=df_drug4, \n", + " x=[\"Genotype\", \"Genotype\"], \n", + " y=\"Tumor Size\", \n", + " delta2=True, \n", + " experiment=\"Treatment\")\n", + "\n", + "dabest_obj5 = dabest.load(data=df_drug5, \n", + " x=[\"Genotype\", \"Genotype\"], \n", + " y=\"Tumor Size\", \n", + " delta2=True, \n", + " experiment=\"Treatment\")\n", + "\n", + "dabest_objs = [dabest_obj1, dabest_obj2, dabest_obj3, dabest_obj4, dabest_obj5]\n", + "dabest_objs2 = [[dabest_obj1, dabest_obj2, dabest_obj3, dabest_obj4, dabest_obj5], [dabest_obj1, dabest_obj2, dabest_obj3, dabest_obj4, dabest_obj5]]\n", + "\n", + "\n", + "multi_1d = combine(dabest_objs, labels=[\"Drug1\", \"Drug2\", \"Drug3\", \"Drug4\", \"Drug5\"], )\n", + "print(multi_1d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## You can plot a forest plot from this MultiContrast object" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig_forest = multi_1d.forest_plot(\n", + " effect_size=\"mean_diff\",\n", + " ci_type=\"bca\", labels=[\"Drug1\", \"Drug2\", \"Drug3\", \"Drug4\", \"Drug5\"]\n", + ")\n", + "plt.title(\"Forest Plot from MultiContrast (1D)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1-D vortexmap also works" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax, mean_delta = vortexmap(\n", + " multi_1d,\n", + " n=30, # Larger spiral size\n", + " vmax=3, vmin=-3, # Extended color range\n", + " reverse_neg=True,\n", + " abs_rank=False,\n", + " chop_tail=5 # Remove 5% extreme values\n", + ")\n", + "# plt.title(\"Customized Vortexmap\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..244792ad --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,11 @@ +[build-system] +requires = ["setuptools>=64.0"] +build-backend = "setuptools.build_meta" + +[project] +name="dabest" +requires-python=">=3.10" +dynamic = [ "keywords", "description", "version", "dependencies", "optional-dependencies", "readme", "license", "authors", "classifiers", "entry-points", "scripts", "urls"] + +[tool.uv] +cache-keys = [{ file = "pyproject.toml" }, { file = "settings.ini" }, { file = "setup.py" }]