diff --git a/CHANGELOG.md b/CHANGELOG.md index f5c9d60b..38e73eac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,17 @@ +## Unreleased + +### New Features +1. **Cluster-aware bootstrap and permutation tests**: `dabest.load()` accepts a new `cluster_col` argument naming the column that identifies the independent sampling unit (cluster) each observation belongs to, such as a participant who contributes several observations or several pairs of paired observations. When it is set, the bootstrap resamples whole clusters with replacement (a cluster bootstrap, stratified by the pattern of groups each cluster appears in) and the permutation test reshuffles labels at the cluster level, so that confidence intervals and permutation p-values account for the correlation between observations from the same cluster. This works for unpaired data, for paired data (`paired` with `id_col`, where `id_col` identifies the pairs and `cluster_col` the units the pairs are nested in), for shared-control and multi-group `idx`, and for delta-delta and mini-meta analyses. The results table gains an `n_clusters` column and `TwoGroupsEffectSize`/`PermutationTest` accept `control_clusters`/`test_clusters` directly. The parametric and rank-based tests in `statistical_tests` are unchanged and still ignore clustering. +2. **Cluster count on plots**: when `cluster_col` is set, each group's axis label reports the number of distinct clusters on a second line below the number of observations, `(N=,` / ` n=)` instead of the usual `(N=)`, since the cluster count is what the bootstrap actually resamples. To make room, the gap between the raw-data and contrast axes of vertical Cumming plots is then sized to the height of the labels (including the taller labels of two-column Sankey plots), so they clear the contrast axes. Unclustered plots are unchanged. +3. **Small-sample expansion of cluster-bootstrap intervals**: bootstrap intervals are too narrow when there are few independent units, so with `cluster_col` set, confidence intervals are now expanded for the number of clusters by default, using the expanded percentile method of Hesterberg (2015). Each interval is read further into the tails of the same bootstrap distribution, at a level derived from a t distribution with degrees of freedom based on the number of clusters (for nested or mixed designs, whose groups of clusters are resampled independently, combined with the Welch-Satterthwaite approximation). This applies to the percentile and bias-corrected and accelerated intervals, and to those of the baseline error curve, delta-delta and mini-meta analyses. The reported confidence level (`ci`) is unchanged, and the level actually read is reported as `ci_expanded` in the results and in the printed summary, with the unexpanded limits alongside (`bca_low_unexpanded` and so on). Because the plotted bootstrap distribution is unchanged, estimation plots and forest plots draw an expanded interval in two parts: the unexpanded interval as the usual thick bar, and the expansion beyond it as a thinner line, which can be styled with `contrast_expanded_errorbar_kwargs` in `.plot()` (or `expanded_errorbar_kwargs` in `forest_plot()`). In simulations, expanded intervals came within about 3 percentage points of nominal coverage for every effect size once there were at least 6 clusters, and at least 4 in each independently resampled group of clusters; below that, a warning is given. Pass `cluster_ci_expansion=False` to `dabest.load()` to turn the expansion off. `cluster_col` can also no longer be the same column as `x`. + +### Documentation +1. **Baseline error curve, explained**: the [Plot Aesthetics tutorial](nbs/tutorials/08-plot_aesthetics.ipynb) and the `show_baseline_ec` docstring now spell out what the baseline error curve (`show_baseline_ec=True`) actually computes, and call out that it is always an *unpaired* self-comparison of the control group, regardless of `paired`. This matters with `cluster_col`: paired real comparisons largely cancel between-cluster variation, but the always-unpaired baseline curve does not, so it can become much wider than the real contrasts once clustering is on. A worked example with and without `cluster_col` is included. +2. **New tutorial: [Cluster-Robust Bootstrap for Repeated Measures](nbs/tutorials/11-cluster_robust_bootstrap.ipynb)**: a self-contained, simulation-based worked example of `cluster_col` for the common case of a participant contributing several sets of paired observations. Its central example is tuned so that, for the identical data and point estimate, the naive dummy-ID bootstrap's 95% interval lies entirely above zero while the cluster-aware interval spans it, making the practical stakes of pseudoreplication concrete rather than abstract. A 200-dataset coverage simulation then shows this is systematic, not a fluke of one dataset: against a known true effect, the naive interval covers the truth only about 82% of the time, the unexpanded cluster-aware interval about 90%, and the default expanded cluster-aware interval about 95%. A section on the small-sample expansion explains when and why it applies. + ## v2025.10.20 ### New Features diff --git a/dabest/_api.py b/dabest/_api.py index 62d0218d..0f65178a 100644 --- a/dabest/_api.py +++ b/dabest/_api.py @@ -25,6 +25,8 @@ def load( x1_level=None, mini_meta=False, ps_adjust=False, + cluster_col=None, + cluster_ci_expansion=True, ): """ Loads data in preparation for estimation statistics. @@ -88,6 +90,57 @@ def load( ps_adjust : boolean, default False Indicator of whether to adjust calculated p-value according to Phipson & Smyth (2010) # https://doi.org/10.2202/1544-6115.1585 + cluster_col : string, default None + Name of the column identifying the independent sampling unit (cluster) + that each observation belongs to, for example a participant who + contributes several observations, or several pairs of paired + observations. When supplied, the bootstrap resamples whole clusters + with replacement (a cluster bootstrap) and the permutation test + reshuffles labels at the cluster level (swapping the control and test + observations of whole clusters, or reassigning whole clusters between + groups when clusters are nested within groups), so that the confidence + intervals and permutation p-values account for the correlation between + observations from the same cluster. This works with both unpaired data + and paired data (`paired` with `id_col`): for paired data, `id_col` + identifies the pairs and `cluster_col` the units the pairs are nested + in, and every pair must belong to a single cluster. The parametric and + rank-based tests reported in `statistical_tests` do not account for + clustering. Note that the baseline error curve shown by + `.plot(show_baseline_ec=True)` is always an unpaired comparison (see + that argument's docstring), so with `cluster_col` set it can become + much wider than a paired analysis's real effect-size curves. + cluster_ci_expansion : boolean, default True + Only used when `cluster_col` is set. Bootstrap confidence intervals are + too narrow when there are few independent units: with around 15 to 30 + clusters, a nominal 95% cluster-bootstrap interval typically covers the + true effect only 90 to 94% of the time. When True, the percentile and + bias-corrected and accelerated intervals (including those of the + baseline error curve, delta-delta and mini-meta analyses) are therefore + expanded for the number of clusters with the expanded percentile + method of Hesterberg (2015, The American Statistician, 69(4), + 371-386): each interval is read further into the tails of the same + bootstrap distribution, at a level derived from a t distribution with + degrees of freedom based on the number of clusters. When clusters are + nested within groups, or some clusters appear in only some groups, the + groups of clusters are resampled independently, and their degrees of + freedom are combined with the Welch-Satterthwaite approximation. The + reported confidence level (`ci`) is unchanged; the level actually read + is reported as `ci_expanded` in the results, alongside the unexpanded + limits (`bca_low_unexpanded` and so on). Plots draw the unexpanded + interval (the nominal `ci`% interval of the plotted bootstrap + distribution) as the usual thick bar, and the expansion beyond it as a + thinner line (see `contrast_expanded_errorbar_kwargs` in `plot()`). The + correction fades as the number of clusters grows. In simulations the + expanded intervals came within about 3 percentage points of nominal + coverage for every effect size once there were at least 6 clusters in + all and at least 4 in each independently resampled group of clusters + (for example 6 participants who each take part in every condition, or + 8 participants split between two conditions); with fewer, no bootstrap + interval is reliable, and a warning is given. Because expanded + intervals are read further into the + tails of the bootstrap distribution, consider increasing `resamples` + (to 20000, say) when there are few clusters. Set to False to report + unexpanded cluster-bootstrap intervals. Returns ------- @@ -112,6 +165,8 @@ def load( x1_level, mini_meta, ps_adjust, + cluster_col=cluster_col, + cluster_ci_expansion=cluster_ci_expansion, ) # %% ../nbs/API/load.ipynb #570ff65a diff --git a/dabest/_dabest_object.py b/dabest/_dabest_object.py index 3153ed61..0b434126 100644 --- a/dabest/_dabest_object.py +++ b/dabest/_dabest_object.py @@ -41,6 +41,8 @@ def __init__( x1_level, mini_meta, ps_adjust, + cluster_col=None, + cluster_ci_expansion=True, ): """ Parses and stores pandas DataFrames in preparation for estimation @@ -60,6 +62,8 @@ def __init__( self.__is_proportional = proportional self.__is_mini_meta = mini_meta self.__ps_adjust = ps_adjust + self.__cluster_col = cluster_col + self.__cluster_ci_expansion = cluster_ci_expansion # after this call the attributes self.__experiment_label and self.__x1_level are updated self._check_errors(x, y, idx, experiment, experiment_label, x1_level) @@ -128,6 +132,16 @@ def __repr__(self): resamples_line2 = "will be used to generate the effect size bootstraps." out.append(resamples_line1 + resamples_line2) + if self.__cluster_col is not None: + cluster_line1 = "Whole clusters, as defined by `{}`, ".format(self.__cluster_col) + cluster_line2 = "will be resampled by the bootstrap and reshuffled by the permutation test." + out.append(cluster_line1 + cluster_line2) + if self.__cluster_ci_expansion: + out.append( + "Confidence intervals will be expanded for the number of clusters " + "(set `cluster_ci_expansion=False` to turn this off)." + ) + return "\n".join(out) @@ -341,6 +355,23 @@ def id_col(self): """ return self.__id_col + @property + def cluster_col(self): + """ + Returns the cluster column declared to `dabest.load()`, if any. + When set, the bootstrap resamples whole clusters of observations and + the permutation test reshuffles labels at the cluster level. + """ + return self.__cluster_col + + @property + def cluster_ci_expansion(self): + """ + Returns whether confidence intervals of clustered data are expanded for + a small number of clusters, as declared to `dabest.load()`. + """ + return self.__cluster_ci_expansion + @property def ci(self): """ @@ -582,6 +613,33 @@ def _check_errors(self, x, y, idx, experiment, experiment_label, x1_level): if self.__id_col not in self.__output_data.columns: err = "`id_col` was given as '{}'; however, '{}' is not a column in `data`.".format(self.__id_col, self.__id_col) raise IndexError(err) + + # Check if `cluster_ci_expansion` is valid + if not isinstance(self.__cluster_ci_expansion, (bool, np.bool_)): + raise TypeError("`cluster_ci_expansion` must be True or False.") + + # Check if `cluster_col` is valid + if self.__cluster_col is not None: + if self.__cluster_col not in self.__output_data.columns: + err = "`cluster_col` was given as '{}'; however, '{}' is not a column in `data`.".format(self.__cluster_col, self.__cluster_col) + raise IndexError(err) + + if y is not None and self.__cluster_col == y: + err = "`cluster_col` cannot be the same column as `y`." + raise ValueError(err) + + x_columns = x if isinstance(x, (list, tuple)) else [x] + if self.__cluster_col in x_columns: + err1 = "`cluster_col` cannot be the same column as `x`: every group would " + err2 = "then be a single cluster, leaving nothing to resample." + raise ValueError(err1 + err2) + + if x is None and idx is not None: + # Wide format: the cluster column cannot also be one of the groups. + groups = [g for item in idx for g in (item if isinstance(item, (tuple, list)) else (item,))] + if self.__cluster_col in groups: + err = "`cluster_col` ('{}') cannot also be one of the groups in `idx`.".format(self.__cluster_col) + raise ValueError(err) # Check if x and y are supplied (relevant to long format data) if x is None and y is not None: @@ -677,8 +735,32 @@ def _get_plot_data(self, x, y, all_plot_groups): plot_data[self.__xvar], categories=all_plot_groups, ordered=True ) + if self.__cluster_col is not None: + self._check_clusters(plot_data) + return plot_data + def _check_clusters(self, plot_data): + """ + Check that the cluster labels are complete and, for paired data, + consistent within each `id_col` value. + """ + clusters = plot_data[self.__cluster_col] + if clusters.isnull().any(): + err1 = "`cluster_col` ('{}') contains missing values.".format(self.__cluster_col) + err2 = " Every observation must belong to a cluster." + raise ValueError(err1 + err2) + + if self.__is_paired: + clusters_per_id = plot_data.groupby(self.__id_col, observed=True)[self.__cluster_col].nunique() + inconsistent = clusters_per_id.index[clusters_per_id > 1].tolist() + if inconsistent: + err1 = "Each value of `id_col` must belong to a single cluster in `cluster_col`," + err2 = " but the following values of '{}' have more than one cluster label: {}.".format( + self.__id_col, inconsistent[:10] + ) + raise ValueError(err1 + err2) + def _compute_effectsize_dfs(self): ''' Function to compute all attributes based on EffectSizeDataFrame. @@ -698,6 +780,7 @@ def _compute_effectsize_dfs(self): x2=self.__x2, mini_meta=self.__is_mini_meta, ps_adjust=self.__ps_adjust, + cluster_ci_expansion=self.__cluster_ci_expansion, ) self.__mean_diff = EffectSizeDataFrame( diff --git a/dabest/_delta_objects.py b/dabest/_delta_objects.py index 3a201cfe..7ccc6dde 100644 --- a/dabest/_delta_objects.py +++ b/dabest/_delta_objects.py @@ -18,6 +18,29 @@ import datetime as dt # %% ../nbs/API/delta_objects.ipynb #1bb53e06 +def _bca_interval_idx(bias, acceleration, resamples, ci, ci_expanded=None): + """ + Indexes of the BCa interval limits. When `ci_expanded` is given (the + interval is expanded for a small number of clusters), the interval is read + at that level; if the BCa adjustment is undefined there, the expanded + percentile limits are used instead. + """ + from ._stats_tools import confint_2group_diff as ci2g + + if ci_expanded is None: + return ci2g.compute_interval_limits(bias, acceleration, resamples, ci) + + low, high = ci2g.expanded_interval_limits(bias, acceleration, resamples, ci_expanded) + if (isnan(low) or isnan(high)) and np.isfinite(bias): + warnings.warn( + "The bias-corrected and accelerated adjustment is undefined at the " + "expanded confidence level; the expanded percentile interval is " + "reported in its place." + ) + low, high = ci2g.percentile_interval_idx(ci_expanded, resamples) + return low, high + + class DeltaDelta(object): r""" A class to compute and store the delta-delta statistics for experiments with a 2-by-2 arrangement where two independent variables, A and B, each have two categorical values, 1 and 2. The data is divided into two pairs of two groups, and a primary delta is first calculated as the mean difference between each of the pairs: @@ -48,7 +71,8 @@ class DeltaDelta(object): """ def __init__( - self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95 + self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95, + ci_expanded=None, ): from ._stats_tools import effsize as es from ._stats_tools import confint_1group as ci1g @@ -57,6 +81,9 @@ def __init__( self.__effsizedf = effectsizedataframe.results self.__dabest_obj = effectsizedataframe.dabest_obj self.__ci = ci + # The level at which the bootstrap distribution is read when the interval + # is expanded for a small number of clusters (see `expanded_ci_level`). + self.__ci_expanded = ci_expanded self.__resamples = effectsizedataframe.resamples self.__effect_size = effectsizedataframe.effect_size self.__alpha = ci2g._compute_alpha_from_ci(ci) @@ -88,8 +115,9 @@ def __init__( self.__acceleration_value = ci2g._calc_accel(self.__jackknives) # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( - self.__bias_correction, self.__acceleration_value, self.__resamples, ci + bca_idx_low, bca_idx_high = _bca_interval_idx( + self.__bias_correction, self.__acceleration_value, self.__resamples, ci, + self.__ci_expanded, ) self.__bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -128,13 +156,22 @@ def __init__( warnings.warn(err_temp.substitute(lim_type="upper"), stacklevel=0) # Compute percentile intervals. - pct_idx_low = int((self.__alpha / 2) * self.__resamples) - pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples + ) self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_delta_delta[pct_idx_low] self.__pct_high = sorted_delta_delta[pct_idx_high] + # For an expanded interval, keep the unexpanded limits too: plots draw + # them as the thick part of the interval. + self.__unexpanded = (None, None, None, None) + if self.__ci_expanded is not None: + self.__unexpanded = ci2g.unexpanded_interval_limits( + sorted_delta_delta, self.__bias_correction, self.__acceleration_value, ci + ) + def __permutation_test(self): """ Perform a permutation test and obtain the permutation p-value @@ -189,8 +226,14 @@ def __repr__(self, header=True, sigfig=3): pvalue = p1 + p2 bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) - bs2 = "the confidence interval is bias-corrected and accelerated." - bs = bs1 + bs2 + bs2 = "the confidence interval is bias-corrected and accelerated" + if self.__ci_expanded is not None: + bs1 = "{} cluster bootstrap samples were taken; ".format(self.__resamples) + bs2 += ( + ", and expanded for the small number of clusters\n(the {}% interval is " + "read at the {:.2f}% level of the bootstrap distribution)".format(ci_width, self.__ci_expanded) + ) + bs = bs1 + bs2 + "." pval_def1 = ( "Any p-value reported is the probability of observing the " @@ -221,11 +264,16 @@ def __compute_results(self): # With some inspiration from @jungyangliao delta_delta_results_df = pd.Series(self.to_dict()).to_frame().T - column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx', - 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test', + column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx', + 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test', 'bootstraps_delta_delta', 'permutations_control', 'permutations_test', 'permutations_delta_delta', 'pvalue_permutation', 'permutation_count', 'bias_correction', 'jackknives' ] + if self.__ci_expanded is not None: + column_index.insert(column_index.index('ci') + 1, 'ci_expanded') + position = column_index.index('pct_interval_idx') + 1 + column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded', + 'pct_low_unexpanded', 'pct_high_unexpanded'] delta_delta_results_df['bootstraps_control'] = [delta_delta_results_df['bootstraps'][0][0]] delta_delta_results_df['bootstraps_test'] = [delta_delta_results_df['bootstraps'][0][1]] delta_delta_results_df['permutations_control'] = [delta_delta_results_df['permutations'][0][0]] @@ -242,6 +290,47 @@ def ci(self): """ return self.__ci + @property + def ci_expanded(self): + """ + The confidence level, in percent, at which the cluster-bootstrap + distribution was read so that the reported `ci`% interval allows for a + small number of clusters. None if the interval was not expanded. + """ + return self.__ci_expanded + + @property + def bca_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa lower + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[0] + + @property + def bca_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa upper + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[1] + + @property + def pct_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + lower limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[2] + + @property + def pct_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + upper limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[3] + @property def alpha(self): """ @@ -440,6 +529,24 @@ def __init__(self, effectsizedataframe, permutation_count, self.__bootstraps_variance = ci2g.calculate_bootstraps_var(self.__bootstraps) + # Expand the interval for a small number of clusters. The weighted delta + # averages the experiments' deltas with weights w_j, so experiment j + # contributes (w_j / sum(w))^2 of its own variance; its stratum + # components are scaled accordingly and combined across experiments. + self.__ci_expanded = None + if (getattr(self.__dabest_obj, "cluster_col", None) is not None + and getattr(effectsizedataframe, "cluster_ci_expansion", False)): + per_experiment = effectsizedataframe._expansion_components + if all(c is not None for c in per_experiment): + weights = 1 / self.__bootstraps_variance + shares = weights / weights.sum() + combined = [(v * share ** 2, n) + for components, share in zip(per_experiment, shares) + for v, n in components] + level, df = ci2g.expanded_ci_level(ci, combined) + if df is not None: + self.__ci_expanded = level + # Compute the weighted average mean differences of the bootstrap data # using the pooled group variances of the raw data as the inverse of # weights @@ -464,9 +571,9 @@ def __init__(self, effectsizedataframe, permutation_count, self.__acceleration_value = ci2g._calc_accel(self.__jackknives) # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( + bca_idx_low, bca_idx_high = _bca_interval_idx( self.__bias_correction, self.__acceleration_value, - self.__resamples, ci) + self.__resamples, ci, self.__ci_expanded) self.__bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -506,12 +613,20 @@ def __init__(self, effectsizedataframe, permutation_count, stacklevel=0) # Compute percentile intervals. - pct_idx_low = int((self.__alpha/2) * self.__resamples) - pct_idx_high = int((1-(self.__alpha/2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples) self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_weighted_deltas[pct_idx_low] self.__pct_high = sorted_weighted_deltas[pct_idx_high] + + # For an expanded interval, keep the unexpanded limits too: plots draw + # them as the thick part of the interval. + self.__unexpanded = (None, None, None, None) + if self.__ci_expanded is not None: + self.__unexpanded = ci2g.unexpanded_interval_limits( + sorted_weighted_deltas, self.__bias_correction, self.__acceleration_value, ci + ) @@ -587,8 +702,14 @@ def __repr__(self, header=True, sigfig=3): bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) - bs2 = "the confidence interval is bias-corrected and accelerated." - bs = bs1 + bs2 + bs2 = "the confidence interval is bias-corrected and accelerated" + if self.__ci_expanded is not None: + bs1 = "{} cluster bootstrap samples were taken; ".format(self.__resamples) + bs2 += ( + ", and expanded for the small number of clusters\n(the {}% interval is " + "read at the {:.2f}% level of the bootstrap distribution)".format(ci_width, self.__ci_expanded) + ) + bs = bs1 + bs2 + "." pval_def1 = "Any p-value reported is the probability of observing the" + \ "effect size (or greater),\nassuming the null hypothesis of " + \ @@ -627,6 +748,11 @@ def __compute_results(self): 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps', 'bootstraps_weighted_delta', 'permutations', 'permutations_var', 'permutations_weighted_delta', 'pvalue_permutation', 'permutation_count', 'bias_correction', 'jackknives'] + if self.__ci_expanded is not None: + column_index.insert(column_index.index('ci') + 1, 'ci_expanded') + position = column_index.index('pct_interval_idx') + 1 + column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded', + 'pct_low_unexpanded', 'pct_high_unexpanded'] mini_meta_delta_results_df = mini_meta_delta_results_df.reindex(columns=column_index) mini_meta_delta_results_df.rename(columns={'bootstraps': 'bootstraps_deltas'}, inplace=True) @@ -641,6 +767,47 @@ def ci(self): """ return self.__ci + @property + def ci_expanded(self): + """ + The confidence level, in percent, at which the cluster-bootstrap + distribution was read so that the reported `ci`% interval allows for a + small number of clusters. None if the interval was not expanded. + """ + return self.__ci_expanded + + @property + def bca_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa lower + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[0] + + @property + def bca_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa upper + limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[1] + + @property + def pct_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + lower limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[2] + + @property + def pct_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + upper limit before expansion; None if the interval was not expanded. + """ + return self.__unexpanded[3] + @property def alpha(self): diff --git a/dabest/_effsize_objects.py b/dabest/_effsize_objects.py index 0671958c..089e29ec 100644 --- a/dabest/_effsize_objects.py +++ b/dabest/_effsize_objects.py @@ -59,6 +59,21 @@ class TwoGroupsEffectSize(object): ps_adjust : boolean, default False. If True, adjust calculated p-value according to Phipson & Smyth (2010) # https://doi.org/10.2202/1544-6115.1585 + control_clusters : array-like, default None + test_clusters : array-like, default None + The cluster (e.g. participant) that each observation in `control` + and `test` belongs to. When supplied, the bootstrap resamples whole + clusters with replacement and the permutation test reshuffles + labels at the cluster level, so that the confidence interval and + permutation p-value account for the correlation between + observations from the same cluster. A label present in both + arrays denotes the same cluster. For paired data the two arrays + must be identical, since observations are paired by position. + cluster_ci_expansion : boolean, default True + Only used when clusters are supplied. If True, the confidence + intervals are expanded for a small number of clusters (see + `dabest.load`); if False, the unexpanded cluster-bootstrap + intervals are reported. Returns @@ -84,6 +99,10 @@ class TwoGroupsEffectSize(object): The bias-corrected and accelerated confidence interval lower limit and upper limits, respectively. `pct_low, pct_high` : float The percentile confidence interval lower limit and upper limits, respectively. + `ci_expanded` : float or None + For clustered data, the confidence level at which the bootstrap + distribution was read so that the reported `ci`% intervals allow for + a small number of clusters; None if the intervals were not expanded. """ def __init__( @@ -98,6 +117,9 @@ def __init__( permutation_count=5000, random_seed=12345, ps_adjust=False, + control_clusters=None, + test_clusters=None, + cluster_ci_expansion=True, ): from ._stats_tools import confint_2group_diff as ci2g from ._stats_tools import effsize as es @@ -118,7 +140,11 @@ def __init__( self.__ci = ci self.__is_proportional = proportional self.__ps_adjust = ps_adjust - self._check_errors(control, test) + self.__is_clustered = control_clusters is not None or test_clusters is not None + if not isinstance(cluster_ci_expansion, (bool, np.bool_)): + raise TypeError("`cluster_ci_expansion` must be True or False.") + self.__cluster_ci_expansion = bool(cluster_ci_expansion) + self._check_errors(control, test, control_clusters, test_clusters) # Convert to numpy arrays for speed. # NaNs are automatically dropped. @@ -128,26 +154,77 @@ def __init__( self.__test = test[~isnan(test)] self.__permutation_count = permutation_count + if self.__is_clustered: + # Keep the cluster labels aligned with the NaN-filtered observations. + self.__control_clusters = array(control_clusters)[~isnan(control)] + self.__test_clusters = array(test_clusters)[~isnan(test)] + (control_codes, test_codes), self.__n_clusters = ci2g.cluster_codes( + self.__control_clusters, self.__test_clusters + ) + if self.__is_paired and not np.array_equal(control_codes, test_codes): + err1 = "In a paired analysis every control observation must belong to the same " + err2 = "cluster as the test observation it is paired with. Check that the data " + err3 = "are sorted so that paired rows are aligned, and that each pair has a single cluster label." + raise ValueError(err1 + err2 + err3) + else: + self.__control_clusters = None + self.__test_clusters = None + self.__n_clusters = None + self.__alpha = ci2g._compute_alpha_from_ci(self.__ci) self.__difference = es.two_group_difference( self.__control, self.__test, self.__is_paired, self.__effect_size ) - self.__jackknives = ci2g.compute_meandiff_jackknife( - self.__control, self.__test, self.__is_paired, self.__effect_size - ) + if self.__is_clustered: + jackknives, deleted, codes, n_codes = ci2g.cluster_jackknife_by_cluster( + self.__control, + self.__test, + self.__control_clusters, + self.__test_clusters, + self.__is_paired, + self.__effect_size, + ) + self.__jackknives = jackknives + # How the jackknife variance splits across the resampling strata, + # used to expand the interval for small numbers of clusters. + self.__expansion_components = ci2g.cluster_variance_components( + jackknives, deleted, codes, n_codes + ) + else: + self.__jackknives = ci2g.compute_meandiff_jackknife( + self.__control, self.__test, self.__is_paired, self.__effect_size + ) + self.__expansion_components = None self.__acceleration_value = ci2g._calc_accel(self.__jackknives) - bootstraps = ci2g.compute_bootstrapped_diff( - self.__control, - self.__test, - self.__is_paired, - self.__effect_size, - self.__resamples, - self.__random_seed, + # Small-sample expansion of the interval for clustered data. + self.__ci_expanded, self.__expansion_df = self._expanded_level( + self.__expansion_components ) + + if self.__is_clustered: + bootstraps = ci2g.compute_cluster_bootstrapped_diff( + self.__control, + self.__test, + self.__control_clusters, + self.__test_clusters, + self.__is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) + else: + bootstraps = ci2g.compute_bootstrapped_diff( + self.__control, + self.__test, + self.__is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) self.__bootstraps = bootstraps sorted_bootstraps = npsort(self.__bootstraps) @@ -173,13 +250,25 @@ def __init__( self._compute_bca_intervals(sorted_bootstraps) # Compute percentile intervals. - pct_idx_low = int((self.__alpha / 2) * self.__resamples) - pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + self._interval_level(), self.__resamples + ) self.__pct_interval_idx = (pct_idx_low, pct_idx_high) self.__pct_low = sorted_bootstraps[pct_idx_low] self.__pct_high = sorted_bootstraps[pct_idx_high] - + + # For an expanded interval, keep the unexpanded limits too: plots draw + # them as the thick part of the interval. + if self.__ci_expanded is not None: + (self.__bca_low_unexpanded, self.__bca_high_unexpanded, + self.__pct_low_unexpanded, self.__pct_high_unexpanded) = ci2g.unexpanded_interval_limits( + sorted_bootstraps, self.__bias_correction, self.__acceleration_value, self.__ci + ) + else: + self.__bca_low_unexpanded = self.__bca_high_unexpanded = None + self.__pct_low_unexpanded = self.__pct_high_unexpanded = None + self._get_bootstrap_baseline_ec() self._perform_statistical_test() @@ -223,25 +312,44 @@ def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3): pval_rounded = base_string_fmt.format(self.pvalue_permutation) - p1 = "The p-value of the two-sided permutation t-test is {}, ".format( - pval_rounded - ) + if self.__is_clustered: + p1 = "The p-value of the two-sided cluster-level permutation test is {}, ".format( + pval_rounded + ) + bs1 = "{} cluster bootstrap samples were taken, resampling {} clusters with replacement; ".format( + self.__resamples, self.__n_clusters + ) + else: + p1 = "The p-value of the two-sided permutation t-test is {}, ".format( + pval_rounded + ) + bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) p2 = "calculated for legacy purposes only. " pvalue = p1 + p2 - bs1 = "{} bootstrap samples were taken; ".format(self.__resamples) - bs2 = "the confidence interval is bias-corrected and accelerated." - bs = bs1 + bs2 + bs2 = "the confidence interval is bias-corrected and accelerated" + if self.__ci_expanded is not None: + bs2 += ( + ", and expanded for the small number of clusters\n(the {}% interval is " + "read at the {:.2f}% level of the bootstrap distribution)".format(ci_width, self.__ci_expanded) + ) + bs = bs1 + bs2 + "." pval_def1 = ( "Any p-value reported is the probability of observing the" + "effect size (or greater),\nassuming the null hypothesis of " + "zero difference is true." ) - pval_def2 = ( - "\nFor each p-value, 5000 reshuffles of the " - + "control and test labels were performed." - ) + if self.__is_clustered: + pval_def2 = ( + "\nFor each p-value, 5000 reshuffles of the control and test labels " + + "were performed at the level of whole clusters." + ) + else: + pval_def2 = ( + "\nFor each p-value, 5000 reshuffles of the " + + "control and test labels were performed." + ) pval_def = pval_def1 + pval_def2 if show_resample_count and define_pval: @@ -253,10 +361,20 @@ def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3): else: return "{}\n{}".format(out, pvalue) - def _check_errors(self, control, test): + def _check_errors(self, control, test, control_clusters=None, test_clusters=None): ''' Function to check configuration errors for the given control and test data. ''' + if self.__is_clustered: + if control_clusters is None or test_clusters is None: + err1 = "Both `control_clusters` and `test_clusters` must be supplied " + err2 = "for a cluster-aware analysis." + raise ValueError(err1 + err2) + if len(control_clusters) != len(control) or len(test_clusters) != len(test): + err1 = "`control_clusters` and `test_clusters` must have the same lengths " + err2 = "as `control` and `test` respectively." + raise ValueError(err1 + err2) + kosher_es = [a for a in self.__EFFECT_SIZE_DICT.keys()] if self.__effect_size not in kosher_es: err1 = "The effect size '{}'".format(self.__effect_size) @@ -279,18 +397,77 @@ def _check_errors(self, control, test): ) raise ValueError(err1) - def _compute_bca_intervals(self, sorted_bootstraps): + def _expanded_level(self, components): ''' - Function to compute the bca intervals given the sorted bootstraps. + The level at which to read the cluster-bootstrap distribution, expanded + for small numbers of clusters, and its degrees of freedom. Returns + `(None, None)` when the interval is not expanded. ''' from ._stats_tools import confint_2group_diff as ci2g + if not (self.__is_clustered and self.__cluster_ci_expansion): + return None, None + + ci_expanded, df = ci2g.expanded_ci_level(self.__ci, components) + if df is None: + warnings.warn( + "There are too few clusters (fewer than 2 in every resampling stratum) " + "to expand the confidence interval for a small number of clusters; " + "the unexpanded interval is reported, and it will be too narrow." + ) + return None, None + # In simulations, expanded intervals came close to nominal coverage once + # there were at least 6 clusters in all, and at least 4 in the smallest + # independently resampled group of clusters. + n_total = sum(n for _, n in components if n >= 2) + n_smallest = ci2g.smallest_cluster_group(components) + if n_total < 6 or n_smallest < 4: + warnings.warn( + "Only {} clusters are available to resample ({} in the smallest group of " + "clusters); even after expansion for the small number of clusters, the " + "confidence interval is unreliable and likely too narrow. At least 6 " + "clusters, and at least 4 in every group of clusters, are " + "recommended.".format(int(n_total), int(n_smallest)) + ) + return ci_expanded, df + + def _interval_level(self): + ''' + The confidence level at which the bootstrap distribution is read: + the expanded level when the interval is expanded, otherwise `ci`. + ''' + return self.__ci_expanded if self.__ci_expanded is not None else self.__ci + + def _bca_interval_idx(self, bias, acceleration, ci_expanded): + ''' + Indexes of the BCa interval limits. When `ci_expanded` is given, the + interval is read at that expanded level; if the BCa adjustment is + undefined there, the expanded percentile limits are used instead. + ''' + from ._stats_tools import confint_2group_diff as ci2g + + if ci_expanded is None: + return ci2g.compute_interval_limits(bias, acceleration, self.__resamples, self.__ci) + + low, high = ci2g.expanded_interval_limits(bias, acceleration, self.__resamples, ci_expanded) + if (isnan(low) or isnan(high)) and np.isfinite(bias): + warnings.warn( + "The bias-corrected and accelerated adjustment is undefined at the " + "expanded confidence level; the expanded percentile interval is " + "reported in its place." + ) + low, high = ci2g.percentile_interval_idx(ci_expanded, self.__resamples) + return low, high + + def _compute_bca_intervals(self, sorted_bootstraps): + ''' + Function to compute the bca intervals given the sorted bootstraps. + ''' # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( + bca_idx_low, bca_idx_high = self._bca_interval_idx( self.__bias_correction, self.__acceleration_value, - self.__resamples, - self.__ci, + self.__ci_expanded, ) self.__bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -342,6 +519,8 @@ def _perform_statistical_test(self): self.__is_paired, self.__permutation_count, ps_adjust = self.__ps_adjust, + control_clusters=self.__control_clusters, + test_clusters=self.__test_clusters, ) if self.__is_paired and not self.__is_proportional: @@ -462,20 +641,53 @@ def _get_bootstrap_baseline_ec(self): ) self.__bec_difference = difference - jackknives = ci2g.compute_meandiff_jackknife( - self.__control, self.__control, is_paired, self.__effect_size - ) + if self.__is_clustered: + # The two copies of the control group are resampled independently, + # so the clusters of the second copy are given distinct labels. + (codes,), n_clusters = ci2g.cluster_codes(self.__control_clusters) + codes_copy = codes + n_clusters + jackknives, deleted, jack_codes, n_codes = ci2g.cluster_jackknife_by_cluster( + self.__control, self.__control, codes, codes_copy, is_paired, self.__effect_size + ) + bec_components = ci2g.cluster_variance_components(jackknives, deleted, jack_codes, n_codes) + else: + jackknives = ci2g.compute_meandiff_jackknife( + self.__control, self.__control, is_paired, self.__effect_size + ) + bec_components = None acceleration_value = ci2g._calc_accel(jackknives) - bootstraps = ci2g.compute_bootstrapped_diff( - self.__control, - self.__control, - is_paired, - self.__effect_size, - self.__resamples, - self.__random_seed, - ) + # The baseline curve is expanded for small numbers of clusters in the same + # way as the effect size itself; the warning for too few clusters, if any, + # has already been given for the effect size. + bec_ci_expanded = None + if self.__ci_expanded is not None: + level, df = ci2g.expanded_ci_level(self.__ci, bec_components) + if df is not None: + bec_ci_expanded = level + self.__bec_ci_expanded = bec_ci_expanded + + if self.__is_clustered: + bootstraps = ci2g.compute_cluster_bootstrapped_diff( + self.__control, + self.__control, + codes, + codes_copy, + is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) + else: + bootstraps = ci2g.compute_bootstrapped_diff( + self.__control, + self.__control, + is_paired, + self.__effect_size, + self.__resamples, + self.__random_seed, + ) self.__bootstraps_baseline_ec = bootstraps sorted_bootstraps = npsort(self.__bootstraps_baseline_ec) @@ -486,11 +698,10 @@ def _get_bootstrap_baseline_ec(self): ) # Compute BCa intervals. - bca_idx_low, bca_idx_high = ci2g.compute_interval_limits( + bca_idx_low, bca_idx_high = self._bca_interval_idx( bias_correction, acceleration_value, - self.__resamples, - self.__ci, + bec_ci_expanded, ) self.__bec_bca_interval_idx = (bca_idx_low, bca_idx_high) @@ -529,13 +740,23 @@ def _get_bootstrap_baseline_ec(self): warnings.warn(err_temp.substitute(lim_type="upper"), stacklevel=0) # Compute percentile intervals. - pct_idx_low = int((self.__alpha / 2) * self.__resamples) - pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples) + pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx( + bec_ci_expanded if bec_ci_expanded is not None else self.__ci, self.__resamples + ) self.__bec_pct_interval_idx = (pct_idx_low, pct_idx_high) self.__bec_pct_low = sorted_bootstraps[pct_idx_low] self.__bec_pct_high = sorted_bootstraps[pct_idx_high] + if bec_ci_expanded is not None: + (self.__bec_bca_low_unexpanded, self.__bec_bca_high_unexpanded, + self.__bec_pct_low_unexpanded, self.__bec_pct_high_unexpanded) = ci2g.unexpanded_interval_limits( + sorted_bootstraps, bias_correction, acceleration_value, self.__ci + ) + else: + self.__bec_bca_low_unexpanded = self.__bec_bca_high_unexpanded = None + self.__bec_pct_low_unexpanded = self.__bec_pct_high_unexpanded = None + @property def difference(self): """ @@ -558,6 +779,56 @@ def is_paired(self): def is_proportional(self): return self.__is_proportional + @property + def is_clustered(self): + """ + Whether whole clusters of observations, rather than individual + observations, were resampled by the bootstrap and permutation test. + """ + return self.__is_clustered + + @property + def n_clusters(self): + """ + The number of distinct clusters resampled by the cluster bootstrap; + None if the observations are not clustered. + """ + return self.__n_clusters + + @property + def cluster_ci_expansion(self): + """ + Whether the confidence interval of clustered data is expanded for a + small number of clusters. + """ + return self.__cluster_ci_expansion + + @property + def ci_expanded(self): + """ + The confidence level, in percent, at which the cluster-bootstrap + distribution was read so that the reported `ci`% interval allows for a + small number of clusters (see `dabest.load`'s `cluster_ci_expansion`). + None if the interval was not expanded. + """ + return self.__ci_expanded + + @property + def expansion_df(self): + """ + The degrees of freedom used to expand the confidence interval for a + small number of clusters; None if the interval was not expanded. + """ + return self.__expansion_df + + @property + def _expansion_components(self): + """ + The stratum-by-stratum `(variance, n_clusters)` components of the + cluster jackknife variance; None if the observations are not clustered. + """ + return self.__expansion_components + @property def ci(self): """ @@ -631,6 +902,38 @@ def pct_high(self): """ return self.__pct_high + @property + def bca_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa lower + limit before expansion; None if the interval was not expanded. + """ + return self.__bca_low_unexpanded + + @property + def bca_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the BCa upper + limit before expansion; None if the interval was not expanded. + """ + return self.__bca_high_unexpanded + + @property + def pct_low_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + lower limit before expansion; None if the interval was not expanded. + """ + return self.__pct_low_unexpanded + + @property + def pct_high_unexpanded(self): + """ + For an interval expanded for a small number of clusters, the percentile + upper limit before expansion; None if the interval was not expanded. + """ + return self.__pct_high_unexpanded + @property def pvalue_brunner_munzel(self): try: @@ -818,6 +1121,38 @@ def bec_pct_high(self): The percentile confidence interval lower limit for baseline error. """ return self.__bec_pct_high + + @property + def bec_bca_low_unexpanded(self): + """ + The baseline error curve's BCa lower limit before expansion for a + small number of clusters; None if it was not expanded. + """ + return self.__bec_bca_low_unexpanded + + @property + def bec_bca_high_unexpanded(self): + """ + The baseline error curve's BCa upper limit before expansion for a + small number of clusters; None if it was not expanded. + """ + return self.__bec_bca_high_unexpanded + + @property + def bec_pct_low_unexpanded(self): + """ + The baseline error curve's percentile lower limit before expansion for + a small number of clusters; None if it was not expanded. + """ + return self.__bec_pct_low_unexpanded + + @property + def bec_pct_high_unexpanded(self): + """ + The baseline error curve's percentile upper limit before expansion for + a small number of clusters; None if it was not expanded. + """ + return self.__bec_pct_high_unexpanded # %% ../nbs/API/effsize_objects.ipynb #024b1d00 @@ -841,6 +1176,7 @@ def __init__( experiment_label=None, mini_meta=False, ps_adjust=False, + cluster_ci_expansion=True, ): """ Parses the data from a Dabest object, enabling plotting and printing @@ -861,6 +1197,9 @@ def __init__( self.__delta2 = delta2 self.__is_mini_meta = mini_meta self.__ps_adjust = ps_adjust + self.__cluster_ci_expansion = cluster_ci_expansion + self.__expansion_components = [] + self.__delta2_ci_expanded = None def __pre_calc(self): from .misc_tools import print_greeting, get_varname @@ -874,10 +1213,21 @@ def __pre_calc(self): out = [] reprs = [] + self.__expansion_components = [] + self.__delta2_ci_expanded = None grouped_data = {name: group[yvar].copy() for name, group in dat.groupby(xvar, observed=False)} + + # The cluster label of every observation, for a cluster-aware analysis. + cluster_col = getattr(self.__dabest_obj, "cluster_col", None) + if cluster_col is not None: + grouped_clusters = {name: group[cluster_col].to_numpy() for name, group in dat.groupby(xvar, observed=False)} + else: + grouped_clusters = {name: None for name in grouped_data} + if self.__delta2: mixed_data = [] + mixed_clusters = [] for j, current_tuple in enumerate(idx): if self.__is_paired != "sequential": cname = current_tuple[0] @@ -890,6 +1240,8 @@ def __pre_calc(self): test = grouped_data[tname] mixed_data.append(control) mixed_data.append(test) + mixed_clusters.append(grouped_clusters[cname]) + mixed_clusters.append(grouped_clusters[tname]) bootstraps_delta_delta = ci2g.compute_delta2_bootstrapped_diff( mixed_data[0], mixed_data[1], @@ -899,7 +1251,17 @@ def __pre_calc(self): self.__resamples, self.__random_seed, self.__is_proportional, + clusters=mixed_clusters if cluster_col is not None else None, ) + if cluster_col is not None and self.__cluster_ci_expansion: + # Expand the delta-delta interval for a small number of clusters. + components = ci2g.delta2_cluster_variance_components( + *[np.asarray(x) for x in mixed_data[:4]], + *mixed_clusters[:4], + self.__is_paired, + ) + level, df = ci2g.expanded_ci_level(self.__ci, components) + self.__delta2_ci_expanded = level if df is not None else None for j, current_tuple in enumerate(idx): if self.__is_paired != "sequential": @@ -921,8 +1283,12 @@ def __pre_calc(self): self.__resamples, self.__permutation_count, self.__random_seed, - self.__ps_adjust + self.__ps_adjust, + control_clusters=grouped_clusters[cname], + test_clusters=grouped_clusters[tname], + cluster_ci_expansion=self.__cluster_ci_expansion, ) + self.__expansion_components.append(result._expansion_components) r_dict = result.to_dict() r_dict["control"] = cname r_dict["test"] = tname @@ -961,16 +1327,22 @@ def __pre_calc(self): "test", "control_N", "test_N", + "n_clusters", "effect_size", "is_paired", "difference", "ci", + "ci_expanded", "bca_low", "bca_high", "bca_interval_idx", "pct_low", "pct_high", "pct_interval_idx", + "bca_low_unexpanded", + "bca_high_unexpanded", + "pct_low_unexpanded", + "pct_high_unexpanded", "bootstraps", "resamples", "random_seed", @@ -1003,6 +1375,10 @@ def __pre_calc(self): "bec_pct_interval_idx", "bec_pct_low", "bec_pct_high", + "bec_bca_low_unexpanded", + "bec_bca_high_unexpanded", + "bec_pct_low_unexpanded", + "bec_pct_high_unexpanded", ] self.__results = out_.reindex(columns=columns_in_order) self.__results.dropna(axis="columns", how="all", inplace=True) @@ -1020,7 +1396,8 @@ def __pre_calc(self): ) elif self.__delta2: self.__delta_delta = DeltaDelta( - self, self.__permutation_count, bootstraps_delta_delta, self.__ci + self, self.__permutation_count, bootstraps_delta_delta, self.__ci, + ci_expanded=self.__delta2_ci_expanded, ) reprs.append(self.__delta_delta.__repr__(header=False)) @@ -1209,6 +1586,7 @@ def plot( contrast_marker_kwargs=None, # es_marker_kwargs=None, OLD contrast_errorbar_kwargs=None, # es_errorbar_kwargs=None, OLD + contrast_expanded_errorbar_kwargs=None, prop_sample_counts=False, prop_sample_counts_kwargs=None, @@ -1300,6 +1678,13 @@ def plot( observations. show_sample_size : boolean, default True Whether or not to display the sample size of each group in the axis label. + When `cluster_col` was set in `dabest.load()`, the label also reports the + number of distinct clusters in that group, on its own line, since that is + the count the cluster-aware bootstrap actually resamples: `(N=, + n=)` instead of the usual `(N=)`. For vertical + Cumming plots, including two-column Sankey plots, the gap between the + raw-data and contrast axes is then sized to the labels, so they clear the + contrast axes. show_delta2, show_mini_meta : boolean, default True If delta-delta or mini-meta delta is calculated, whether or not to show the delta-delta plot or mini-meta plot. @@ -1438,6 +1823,16 @@ def plot( contrast_errorbar_kwargs: dict, default None Pass relevant keyword arguments to the effectsize errorbar plotting. If none, the following keywords are passed: {'color': 'black', 'lw': 2, 'linestyle': '-', 'alpha': 1,'zorder': 1,} + contrast_expanded_errorbar_kwargs: dict, default None + When `cluster_col` is set, intervals are expanded for the number of + clusters (see `dabest.load`'s `cluster_ci_expansion`). The plotted + bootstrap distribution does not change, so the expanded interval + reaches further into its tails than its nominal `ci`% interval. To + show this, the unexpanded interval (the nominal `ci`% interval of + the plotted distribution) is drawn as the usual errorbar, and the + expansion beyond it as a thinner line. Pass keyword arguments here + to style the thinner line; by default it takes the errorbar's + keywords at 40% of its line width. prop_sample_counts: bool, default False Show the sample counts for each group in proportional plots @@ -1452,10 +1847,22 @@ def plot( {"linestyle": "-", "linewidth": 2, "zorder": -2, "color": 'dimgray', "alpha": 1} show_baseline_ec : boolean, default False - Whether or not to display the baseline error curve. The baseline error curve - represents the distribution of the effect size when comparing the control - group to itself, providing a reference for the inherent variability or noise - in the data. When True, this curve is plotted alongside the main effect size + Whether or not to display the baseline error curve (bec). The bec is the + bootstrap distribution obtained by comparing the leftmost ("control") group + of each `idx` tuple to a resample of itself, so that its own difference is + 0 and its spread shows the sampling noise inherent to that group alone. It + is always computed as an *unpaired* comparison, even when `paired` is set + for the main analysis, because it stands in for "no relationship between + the two sides of the comparison" rather than for the design actually used. + For a paired analysis this means the bec is not directly comparable in + scale to the real (paired) effect-size curves: pairing removes shared + between-subject variation from the real curves but not from the bec, and + when `cluster_col` is set this asymmetry is amplified, since the bec then + resamples whole clusters against an independent resample of themselves, + while the real paired curves largely cancel the between-cluster variation. + The bec can be much wider than the real curves in that case, and may need + its own `contrast_ylim`; see the Plot Aesthetics tutorial for an example. + When True, this curve is plotted alongside the main effect size distribution, allowing for a visual comparison of the observed effect against the baseline variability. @@ -1535,6 +1942,11 @@ def statistical_tests(self): "bca_high", ] + if "n_clusters" in results_df.columns: + default_cols.insert(default_cols.index("effect_size"), "n_clusters") + if "ci_expanded" in results_df.columns: + default_cols.insert(default_cols.index("ci") + 1, "ci_expanded") + cols_of_interest = default_cols + stats_columns return results_df[cols_of_interest] @@ -1543,6 +1955,27 @@ def statistical_tests(self): def _for_print(self): return self.__for_print + @property + def cluster_ci_expansion(self): + """ + Whether confidence intervals of clustered data are expanded for a small + number of clusters. + """ + return self.__cluster_ci_expansion + + @property + def _expansion_components(self): + """ + For each comparison, in the order of `results`, the stratum-by-stratum + `(variance, n_clusters)` components of its cluster jackknife variance, + or None if the observations are not clustered. + """ + try: + self.__results + except AttributeError: + self.__pre_calc() + return self.__expansion_components + @property def _plot_data(self): return self.__dabest_obj._plot_data @@ -1661,6 +2094,14 @@ def is_delta_delta(self): return self.__delta2 # %% ../nbs/API/effsize_objects.ipynb #5d49f77f +def _count_sign_patterns(n): + """The number of ways to swap or not swap each of `n` clusters, as a float.""" + try: + return float(2 ** int(n)) + except OverflowError: + return float("inf") + + class PermutationTest: """ A class to compute and report permutation tests. @@ -1683,6 +2124,17 @@ class PermutationTest: ps_adjust : bool, default False If True, the p-value is adjusted according to Phipson & Smyth (2010). # https://doi.org/10.2202/1544-6115.1585 + control_clusters : array-like, default None + test_clusters : array-like, default None + The cluster (e.g. participant) that each observation in `control` and + `test` belongs to. When supplied, labels are reshuffled at the cluster + level: for paired data, control and test are swapped for whole clusters + at a time; for unpaired data with clusters nested within groups, whole + clusters are reassigned between the groups; and for unpaired data with + clusters spanning both groups, each cluster's control and test + observations are swapped as whole sets. In every case the observations + within a cluster are kept together, so that heterogeneity of the effect + between clusters is reflected in the null distribution. Returns @@ -1703,9 +2155,16 @@ def __init__(self, control: array, permutation_count:int=5000, # The number of permutations (reshuffles) to perform. random_seed:int=12345,#`random_seed` is used to seed the random number generator during bootstrap resampling. This ensures that the generated permutations are replicable. ps_adjust:bool=False, + control_clusters=None, # Cluster label of each observation in `control`; see the class docstring. + test_clusters=None, # Cluster label of each observation in `test`. **kwargs): from ._stats_tools.effsize import two_group_difference - from ._stats_tools.confint_2group_diff import calculate_group_var + from ._stats_tools.confint_2group_diff import ( + calculate_group_var, + cluster_codes, + cluster_tables, + expand_cluster_draw, + ) self.__permutation_count = permutation_count @@ -1714,6 +2173,12 @@ def __init__(self, control: array, if is_paired and len(control) != len(test): raise ValueError("The two arrays do not have the same length.") + is_clustered = control_clusters is not None or test_clusters is not None + if is_clustered and (control_clusters is None or test_clusters is None): + err1 = "Both `control_clusters` and `test_clusters` must be supplied " + err2 = "for a cluster-aware permutation test." + raise ValueError(err1 + err2) + # Initialise random number generator. # rng = random.default_rng(seed=random_seed) rng = RandomState(PCG64(random_seed)) @@ -1734,8 +2199,79 @@ def __init__(self, control: array, self.__permutations = [] self.__permutations_var = [] - for i in range(int(self.__permutation_count)): + # The number of distinct (two-sided) permutations, used by the + # Phipson & Smyth (2010) adjustment. + if is_clustered: + (control_codes, test_codes), n_clusters = cluster_codes(control_clusters, test_clusters) + if len(control_codes) != CONTROL_LEN or len(test_codes) != TEST_LEN: + err1 = "`control_clusters` and `test_clusters` must have the same lengths " + err2 = "as `control` and `test` respectively." + raise ValueError(err1 + err2) + if is_paired: + if not np.array_equal(control_codes, test_codes): + err1 = "In a paired analysis every control observation must belong to the " + err2 = "same cluster as the test observation it is paired with." + raise ValueError(err1 + err2) + # Control and test are swapped for whole clusters at a time; each + # pattern of swaps and its mirror image give the same |effect size|. + totalPermutations = _count_sign_patterns(n_clusters) / 2 + else: + bag_codes = array([*control_codes, *test_codes]) + offsets, members = cluster_tables(bag_codes, n_clusters) + cluster_sizes = offsets[1:] - offsets[:-1] + control_per_cluster = np.bincount(control_codes, minlength=n_clusters) + clusters_shared = bool( + ((control_per_cluster > 0) & (control_per_cluster < cluster_sizes)).any() + ) + + if clusters_shared: + # Clusters contribute to both groups: a cluster's control and + # test observations are swapped as whole sets (the analogue of + # the paired sign flip). Clusters present in one group only + # are left where they are. + shared_cluster = (control_per_cluster > 0) & (control_per_cluster < cluster_sizes) + n_shared = int(shared_cluster.sum()) + is_control = arange(len(BAG)) < CONTROL_LEN + if n_shared == n_clusters: + # Swapping every cluster mirrors the effect size exactly. + totalPermutations = _count_sign_patterns(n_shared) / 2 + else: + totalPermutations = _count_sign_patterns(n_shared) + else: + # Clusters are nested within groups: whole clusters are + # reassigned between the control and test groups. + n_control_clusters = int((control_per_cluster > 0).sum()) + if 2 * n_control_clusters == n_clusters: + totalPermutations = binomcoeff(n_clusters, n_control_clusters) / 2 + else: + totalPermutations = binomcoeff(n_clusters, n_control_clusters) + elif CONTROL_LEN == TEST_LEN: + totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) / 2 + else: + totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) + + for i in range(int(self.__permutation_count)): + if is_clustered and is_paired: + # Swap control and test for whole clusters at a time. + flip = rng.randint(0, 2, n_clusters).astype(bool)[control_codes] + control_sample = np.where(flip, test, control) + test_sample = np.where(flip, control, test) + + elif is_clustered and clusters_shared: + # Swap the control and test sets of randomly chosen shared clusters. + swap = rng.randint(0, 2, n_clusters).astype(bool) & shared_cluster + new_is_control = is_control ^ swap[bag_codes] + control_sample = BAG[new_is_control] + test_sample = BAG[~new_is_control] + + elif is_clustered: + # Reassign whole clusters between the control and test groups. + perm = rng.permutation(n_clusters).astype(np.int64) + control_sample = BAG[expand_cluster_draw(perm[:n_control_clusters], offsets, members)] + test_sample = BAG[expand_cluster_draw(perm[n_control_clusters:], offsets, members)] + + elif is_paired: # Select which control-test pairs to swap. random_idx = rng.choice(CONTROL_LEN, rng.randint(0, CONTROL_LEN+1), @@ -1759,7 +2295,7 @@ def __init__(self, control: array, False, effect_size) group_var = calculate_group_var(var(control_sample, ddof=1), - CONTROL_LEN, + len(control_sample), var(test_sample, ddof=1), len(test_sample)) self.__permutations.append(es) @@ -1776,11 +2312,6 @@ def __init__(self, control: array, # https://rdrr.io/cran/statmod/src/R/permp.R # (assumes two-sided test) - if CONTROL_LEN == TEST_LEN: - totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)/2 - else: - totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) - if totalPermutations <= 10e3: # use exact calculation p = arange(1, totalPermutations + 1)/totalPermutations diff --git a/dabest/_modidx.py b/dabest/_modidx.py index 96231c81..58e1d9ac 100644 --- a/dabest/_modidx.py +++ b/dabest/_modidx.py @@ -19,12 +19,16 @@ 'dabest/_stats_tools/confint_1group.py')}, 'dabest._stats_tools.confint_2group_diff': { 'dabest._stats_tools.confint_2group_diff._calc_accel': ( 'API/confint_2group_diff.html#_calc_accel', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff._check_paired_clusters': ( 'API/confint_2group_diff.html#_check_paired_clusters', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff._compute_alpha_from_ci': ( 'API/confint_2group_diff.html#_compute_alpha_from_ci', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff._compute_quantile': ( 'API/confint_2group_diff.html#_compute_quantile', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff._create_two_group_jackknife_indexes': ( 'API/confint_2group_diff.html#_create_two_group_jackknife_indexes', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff._usable_components': ( 'API/confint_2group_diff.html#_usable_components', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.bootstrap_indices': ( 'API/confint_2group_diff.html#bootstrap_indices', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.calculate_bootstraps_var': ( 'API/confint_2group_diff.html#calculate_bootstraps_var', @@ -33,8 +37,24 @@ 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.calculate_weighted_delta': ( 'API/confint_2group_diff.html#calculate_weighted_delta', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_bootstrap_draws': ( 'API/confint_2group_diff.html#cluster_bootstrap_draws', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_codes': ( 'API/confint_2group_diff.html#cluster_codes', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_jackknife_by_cluster': ( 'API/confint_2group_diff.html#cluster_jackknife_by_cluster', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_strata': ( 'API/confint_2group_diff.html#cluster_strata', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_tables': ( 'API/confint_2group_diff.html#cluster_tables', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.cluster_variance_components': ( 'API/confint_2group_diff.html#cluster_variance_components', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_bootstrapped_diff', 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.compute_cluster_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_cluster_bootstrapped_diff', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.compute_cluster_jackknife': ( 'API/confint_2group_diff.html#compute_cluster_jackknife', + 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_delta2_bootstrapped_diff': ( 'API/confint_2group_diff.html#compute_delta2_bootstrapped_diff', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.compute_interval_limits': ( 'API/confint_2group_diff.html#compute_interval_limits', @@ -48,7 +68,23 @@ 'dabest._stats_tools.confint_2group_diff.create_repeated_indexes': ( 'API/confint_2group_diff.html#create_repeated_indexes', 'dabest/_stats_tools/confint_2group_diff.py'), 'dabest._stats_tools.confint_2group_diff.delta2_bootstrap_loop': ( 'API/confint_2group_diff.html#delta2_bootstrap_loop', - 'dabest/_stats_tools/confint_2group_diff.py')}, + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.delta2_cluster_bootstrap_loop': ( 'API/confint_2group_diff.html#delta2_cluster_bootstrap_loop', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.delta2_cluster_variance_components': ( 'API/confint_2group_diff.html#delta2_cluster_variance_components', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.expand_cluster_draw': ( 'API/confint_2group_diff.html#expand_cluster_draw', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.expanded_ci_level': ( 'API/confint_2group_diff.html#expanded_ci_level', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.expanded_interval_limits': ( 'API/confint_2group_diff.html#expanded_interval_limits', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.percentile_interval_idx': ( 'API/confint_2group_diff.html#percentile_interval_idx', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.smallest_cluster_group': ( 'API/confint_2group_diff.html#smallest_cluster_group', + 'dabest/_stats_tools/confint_2group_diff.py'), + 'dabest._stats_tools.confint_2group_diff.unexpanded_interval_limits': ( 'API/confint_2group_diff.html#unexpanded_interval_limits', + 'dabest/_stats_tools/confint_2group_diff.py')}, 'dabest._stats_tools.effsize': { 'dabest._stats_tools.effsize._cliffs_delta_core': ( 'API/effsize.html#_cliffs_delta_core', 'dabest/_stats_tools/effsize.py'), 'dabest._stats_tools.effsize._compute_hedges_correction_factor': ( 'API/effsize.html#_compute_hedges_correction_factor', @@ -79,7 +115,11 @@ 'dabest.forest_plot.forest_plot': ('API/forest_plot.html#forest_plot', 'dabest/forest_plot.py'), 'dabest.forest_plot.get_kwargs': ('API/forest_plot.html#get_kwargs', 'dabest/forest_plot.py'), 'dabest.forest_plot.load_plot_data': ('API/forest_plot.html#load_plot_data', 'dabest/forest_plot.py')}, - 'dabest.misc_tools': { 'dabest.misc_tools.add_counts_to_ticks': ( 'API/misc_tools.html#add_counts_to_ticks', + 'dabest.misc_tools': { 'dabest.misc_tools._hspace_for_tick_labels': ( 'API/misc_tools.html#_hspace_for_tick_labels', + 'dabest/misc_tools.py'), + 'dabest.misc_tools._tick_label_gap_inches': ( 'API/misc_tools.html#_tick_label_gap_inches', + 'dabest/misc_tools.py'), + 'dabest.misc_tools.add_counts_to_ticks': ( 'API/misc_tools.html#add_counts_to_ticks', 'dabest/misc_tools.py'), 'dabest.misc_tools.color_picker': ('API/misc_tools.html#color_picker', 'dabest/misc_tools.py'), 'dabest.misc_tools.draw_zeroline': ('API/misc_tools.html#draw_zeroline', 'dabest/misc_tools.py'), @@ -165,10 +205,13 @@ 'dabest.plot_tools.effect_size_curve_plotter': ( 'API/plot_tools.html#effect_size_curve_plotter', 'dabest/plot_tools.py'), 'dabest.plot_tools.error_bar': ('API/plot_tools.html#error_bar', 'dabest/plot_tools.py'), + 'dabest.plot_tools.expanded_errorbar_kwargs_from': ( 'API/plot_tools.html#expanded_errorbar_kwargs_from', + 'dabest/plot_tools.py'), 'dabest.plot_tools.get_swarm_spans': ('API/plot_tools.html#get_swarm_spans', 'dabest/plot_tools.py'), 'dabest.plot_tools.gridkey_plotter': ('API/plot_tools.html#gridkey_plotter', 'dabest/plot_tools.py'), 'dabest.plot_tools.halfviolin': ('API/plot_tools.html#halfviolin', 'dabest/plot_tools.py'), 'dabest.plot_tools.normalize_dict': ('API/plot_tools.html#normalize_dict', 'dabest/plot_tools.py'), + 'dabest.plot_tools.plot_ci_whisker': ('API/plot_tools.html#plot_ci_whisker', 'dabest/plot_tools.py'), 'dabest.plot_tools.plot_minimeta_or_deltadelta_violins': ( 'API/plot_tools.html#plot_minimeta_or_deltadelta_violins', 'dabest/plot_tools.py'), 'dabest.plot_tools.sankeydiag': ('API/plot_tools.html#sankeydiag', 'dabest/plot_tools.py'), @@ -178,5 +221,6 @@ 'dabest.plot_tools.swarmplot': ('API/plot_tools.html#swarmplot', 'dabest/plot_tools.py'), 'dabest.plot_tools.table_for_horizontal_plots': ( 'API/plot_tools.html#table_for_horizontal_plots', 'dabest/plot_tools.py'), + 'dabest.plot_tools.unexpanded_limits': ('API/plot_tools.html#unexpanded_limits', 'dabest/plot_tools.py'), 'dabest.plot_tools.width_determine': ('API/plot_tools.html#width_determine', 'dabest/plot_tools.py')}, 'dabest.plotter': {'dabest.plotter.effectsize_df_plotter': ('API/plotter.html#effectsize_df_plotter', 'dabest/plotter.py')}}} diff --git a/dabest/_stats_tools/confint_2group_diff.py b/dabest/_stats_tools/confint_2group_diff.py index c662ea29..a4154544 100644 --- a/dabest/_stats_tools/confint_2group_diff.py +++ b/dabest/_stats_tools/confint_2group_diff.py @@ -6,9 +6,13 @@ # %% auto #0 __all__ = ['create_jackknife_indexes', 'create_repeated_indexes', 'compute_meandiff_jackknife', 'bootstrap_indices', - 'compute_bootstrapped_diff', 'delta2_bootstrap_loop', 'compute_delta2_bootstrapped_diff', - 'compute_meandiff_bias_correction', 'compute_interval_limits', 'calculate_group_var', - 'calculate_bootstraps_var', 'calculate_weighted_delta'] + 'compute_bootstrapped_diff', 'cluster_codes', 'cluster_tables', 'cluster_strata', 'cluster_bootstrap_draws', + 'expand_cluster_draw', 'compute_cluster_jackknife', 'cluster_jackknife_by_cluster', + 'cluster_variance_components', 'smallest_cluster_group', 'expanded_ci_level', 'percentile_interval_idx', + 'unexpanded_interval_limits', 'expanded_interval_limits', 'compute_cluster_bootstrapped_diff', + 'delta2_cluster_bootstrap_loop', 'delta2_cluster_variance_components', 'delta2_bootstrap_loop', + 'compute_delta2_bootstrapped_diff', 'compute_meandiff_bias_correction', 'compute_interval_limits', + 'calculate_group_var', 'calculate_bootstraps_var', 'calculate_weighted_delta'] # %% ../../nbs/API/confint_2group_diff.ipynb #fa733643 import numpy as np @@ -162,6 +166,436 @@ def compute_bootstrapped_diff( return out +def cluster_codes(*cluster_labels): + """ + Convert cluster labels from one or more groups into contiguous integer codes. + + The labels of all groups are pooled, so that the same label appearing in + several groups (e.g. a participant measured under every condition) maps + to the same code. Codes are assigned in order of first appearance. + + Returns + ------- + codes : list of int64 numpy arrays, one per input group. + n_clusters : int + The number of distinct clusters across all groups. + """ + import pandas as pd + + arrays = [np.asarray(a) for a in cluster_labels] + joined = np.concatenate(arrays) if len(arrays) > 1 else arrays[0] + codes, uniques = pd.factorize(pd.Series(joined), sort=False) + codes = codes.astype(np.int64) + if (codes < 0).any(): + raise ValueError("Cluster labels must not contain missing values.") + + out, start = [], 0 + for a in arrays: + out.append(codes[start : start + len(a)]) + start += len(a) + return out, len(uniques) + + +def cluster_tables(codes, n_clusters): + """ + Build the membership tables used by `expand_cluster_draw`. + + Returns `(offsets, members)` such that `members[offsets[g]:offsets[g+1]]` + holds the positions (in the original array) of the observations that + belong to cluster `g`. A cluster absent from the array has an empty slice. + """ + codes = np.asarray(codes, dtype=np.int64) + members = np.argsort(codes, kind="stable").astype(np.int64) + counts = np.bincount(codes, minlength=n_clusters) + offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64) + return offsets, members + + +def cluster_strata(codes_per_group, n_clusters): + """ + Partition the clusters into resampling strata. + + Clusters are stratified by the pattern of groups in which they appear, so + that every bootstrap resample preserves the observed design. For a fully + within-cluster design (every cluster present in every group) there is a + single stratum and clusters are resampled jointly across the groups; for a + nested design (each cluster present in one group only) the clusters are + resampled separately within each group. + + Returns `(strata_clusters, strata_offsets)`: the cluster codes concatenated + stratum by stratum, and the boundaries of each stratum in that array. + """ + pattern = np.zeros(n_clusters, dtype=np.int64) + for k, codes in enumerate(codes_per_group): + present = np.zeros(n_clusters, dtype=bool) + present[np.asarray(codes, dtype=np.int64)] = True + pattern |= present.astype(np.int64) << k + + strata_clusters = np.argsort(pattern, kind="stable").astype(np.int64) + _, counts = np.unique(pattern, return_counts=True) + strata_offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64) + return strata_clusters, strata_offsets + + +@njit(cache=True) # parallelization must be turned off for random number generation +def cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed): + """ + Draw clusters with replacement, separately within each stratum + (see `cluster_strata`). + + Returns an array of shape `(resamples, n_clusters)` holding, for each + resample, the codes of the clusters drawn. + """ + np.random.seed(random_seed) + n_clusters = len(strata_clusters) + n_strata = len(strata_offsets) - 1 + draws = np.empty((resamples, n_clusters), dtype=np.int64) + + for i in range(resamples): + for s in range(n_strata): + start = strata_offsets[s] + size = strata_offsets[s + 1] - start + picks = np.random.choice(size, size) + for k in range(size): + draws[i, start + k] = strata_clusters[start + picks[k]] + return draws + + +@njit(cache=True) +def expand_cluster_draw(draw, offsets, members): + """ + Expand a draw of cluster codes into the positions of all the observations + that belong to those clusters (see `cluster_tables`). + """ + total = 0 + for j in range(len(draw)): + g = draw[j] + total += offsets[g + 1] - offsets[g] + + out = np.empty(total, dtype=np.int64) + pos = 0 + for j in range(len(draw)): + g = draw[j] + for k in range(offsets[g], offsets[g + 1]): + out[pos] = members[k] + pos += 1 + return out + + +def _check_paired_clusters(c0, c1): + """Paired observations must share a cluster.""" + if len(c0) != len(c1) or not np.array_equal(c0, c1): + err1 = "In a paired analysis every control observation must belong to the same cluster " + err2 = "as the test observation it is paired with. Check that the data are sorted so " + err3 = "that paired rows are aligned, and that each pair has a single cluster label." + raise ValueError(err1 + err2 + err3) + + +def compute_cluster_jackknife(x0, x1, c0, c1, is_paired, effect_size): + """ + Delete-one-cluster jackknife of the effect size for 2 groups. + + Used to compute the acceleration term of the BCa interval when the + observations are clustered. `c0` and `c1` hold the cluster label of each + observation in `x0` and `x1`. + """ + values, _, _, _ = cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size) + return values + + +def cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size): + """ + Delete-one-cluster jackknife of the effect size for 2 groups, keeping track + of which cluster each jackknife value leaves out. + + Returns `(values, deleted_codes, (codes0, codes1), n_clusters)`, where + `values[i]` is the effect size with cluster `deleted_codes[i]` removed, and + `codes0`/`codes1` are the integer cluster codes of the observations in + `x0`/`x1` (see `cluster_codes`). Clusters whose removal would empty a group + are skipped. + """ + from . import effsize as __es + + x0, x1 = np.asarray(x0), np.asarray(x1) + (c0, c1), n_clusters = cluster_codes(c0, c1) + if is_paired: + _check_paired_clusters(c0, c1) + + values, deleted = [], [] + for g in range(n_clusters): + keep0 = c0 != g + keep1 = c1 != g + if not keep0.any() or not keep1.any(): + # Deleting this cluster would empty one of the groups. + continue + values.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size)) + deleted.append(g) + return values, deleted, (c0, c1), n_clusters + + +def cluster_variance_components(jackknife_values, deleted_codes, codes_per_group, n_clusters): + """ + Split the delete-one-cluster jackknife variance of an estimate into the + contributions of the resampling strata (see `cluster_strata`). + + Returns a list of `(variance, n)` pairs, one per stratum of `n` clusters, + where `variance` is that stratum's term of the stratified jackknife + variance estimate. Strata with fewer than 2 clusters are left out: the + cluster bootstrap cannot vary them, and they carry no information about + the number of degrees of freedom. Non-finite jackknife values are ignored. + """ + strata_clusters, strata_offsets = cluster_strata(codes_per_group, n_clusters) + value_of = {g: v for g, v in zip(deleted_codes, jackknife_values) if np.isfinite(v)} + + components = [] + for s in range(len(strata_offsets) - 1): + members = strata_clusters[strata_offsets[s] : strata_offsets[s + 1]] + n = len(members) + if n < 2: + continue + values = np.array([value_of[g] for g in members if g in value_of], dtype=float) + if len(values) < 2: + continue + variance = (n - 1) / n * np.sum((values - values.mean()) ** 2) + components.append((float(variance), int(n))) + return components + + +# The smallest tail probability an expanded interval is read at. It keeps the +# quantile functions finite; any value this small already selects the extreme +# bootstrap resamples for any practical number of resamples. +_MIN_EXPANDED_ALPHA = 1e-6 + +# Strata carrying less than this share of the variance are not counted when +# judging whether the smallest group of clusters is too small for a reliable +# interval (see `smallest_cluster_group`), so that a stray handful of clusters +# (say, two participants seen in only one condition) does not trigger a warning. +_MIN_VARIANCE_SHARE = 0.1 + + +def _usable_components(components): + """Strata with at least 2 clusters, as arrays of variances and sizes.""" + components = [(v, n) for v, n in components if n >= 2] + if not components: + return None, None + variances = np.array([v for v, _ in components], dtype=float) + n = np.array([n for _, n in components], dtype=float) + if not np.all(np.isfinite(variances)) or variances.sum() <= 0: + # No usable variance information: weight the strata equally. + variances = np.ones_like(n) + return variances, n + + +def smallest_cluster_group(components): + """ + The number of clusters in the smallest stratum that carries at least 10% + of the variance (see `cluster_variance_components`); None if no stratum + has at least 2 clusters. + """ + variances, n = _usable_components(components) + if n is None: + return None + shares = variances / variances.sum() + # Never let the threshold exclude every stratum (e.g. many equal strata). + threshold = min(_MIN_VARIANCE_SHARE, shares.max()) + return int(n[shares >= threshold].min()) + + +def expanded_ci_level(ci, components): + """ + The confidence level at which to read a cluster-bootstrap distribution so + that the resulting interval has approximately `ci`% coverage when there + are few clusters. + + Bootstrap intervals are too narrow when there are few independent units: + the bootstrap reproduces a variance with divisor `n` rather than `n - 1`, + and normal rather than t-distributed tails. This applies the expanded + percentile correction of Hesterberg (2015, The American Statistician, + 69(4), 371-386) with the number of clusters as `n`: the interval is read + at the level whose normal quantile equals `sqrt(n/(n-1))` times the + t quantile with `n - 1` degrees of freedom. + + When the bootstrap resamples several strata independently (for example + clusters nested within groups), `components` holds each stratum's + `(variance, n)` (see `cluster_variance_components`). The narrowness + correction is then applied stratum by stratum, weighted by each stratum's + share of the variance, and the degrees of freedom come from the + Welch-Satterthwaite approximation. Both reduce to the single-sample + correction above for one stratum. In simulations of unbalanced or mixed + designs whose smallest group held only 4 to 6 clusters, Welch-Satterthwaite + intervals covered 1 to 3 points below nominal; the more conservative + alternative of the smallest stratum's degrees of freedom over-covered by + similar amounts, with intervals about 10% wider. + + Returns `(ci_expanded, df)`, or `(ci, None)` if no stratum has at least + 2 clusters, in which case no expansion is possible. + """ + from scipy.stats import t as student_t + + variances, n = _usable_components(components) + if n is None: + return ci, None + + total = variances.sum() + narrowness = np.sqrt(total / np.sum(variances * (n - 1) / n)) + df = float(total ** 2 / np.sum(variances ** 2 / (n - 1))) + + alpha = _compute_alpha_from_ci(ci) + z = narrowness * student_t.ppf(1 - alpha / 2, df) + alpha_expanded = max(2 * norm.sf(z), _MIN_EXPANDED_ALPHA) + return 100 * (1 - alpha_expanded), float(df) + + +def percentile_interval_idx(ci, n_boots): + """ + Indexes of the percentile interval limits in a sorted array of `n_boots` + bootstrap values, kept within the array. + """ + alpha = _compute_alpha_from_ci(ci) + low = int((alpha / 2) * n_boots) + high = int((1 - alpha / 2) * n_boots) + return min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) + + +def unexpanded_interval_limits(sorted_bootstraps, bias, acceleration, ci): + """ + The BCa and percentile limits at the nominal level `ci`, as + `(bca_low, bca_high, pct_low, pct_high)`, for an interval that has been + expanded for a small number of clusters. Plots show this unexpanded + interval, which the bootstrap distribution itself spans, as the thick part + of the interval, and the expansion beyond it as a thinner line. If the BCa + limits cannot be computed, the percentile limits are used for both. + """ + n_boots = len(sorted_bootstraps) + pct_low, pct_high = percentile_interval_idx(ci, n_boots) + low, high = compute_interval_limits(bias, acceleration, n_boots, ci) + if isnan(low) or isnan(high): + low, high = pct_low, pct_high + else: + low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) + return (sorted_bootstraps[low], sorted_bootstraps[high], + sorted_bootstraps[pct_low], sorted_bootstraps[pct_high]) + + +def expanded_interval_limits(bias, acceleration, n_boots, ci_expanded): + """ + Indexes of the BCa interval limits at the expanded level `ci_expanded` + (see `expanded_ci_level`), kept within the array of bootstrap values. + + Returns `(nan, nan)` if the BCa adjustment is undefined at this level, + which can happen when a large acceleration meets a very extreme level; + callers should then fall back to the expanded percentile interval. + """ + alpha = _compute_alpha_from_ci(ci_expanded) + for z in (norm.ppf(alpha / 2), norm.ppf(1 - alpha / 2)): + if not np.isfinite(bias) or not np.isfinite(acceleration) or 1 - acceleration * (bias + z) <= 0: + return np.nan, np.nan + + low, high = compute_interval_limits(bias, acceleration, n_boots, ci_expanded) + if isnan(low) or isnan(high): + return np.nan, np.nan + low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1) + if low > high: + return np.nan, np.nan + return low, high + + +def compute_cluster_bootstrapped_diff( + x0, x1, c0, c1, is_paired, effect_size, resamples=5000, random_seed=12345 +): + """ + Cluster bootstrap of the effect size for 2 groups. + + Instead of resampling individual observations (or pairs), whole clusters + of observations (e.g. all the observations contributed by one participant) + are resampled with replacement, so that the correlation between + observations from the same cluster is preserved in every resample. + + `c0` and `c1` hold the cluster label of each observation in `x0` and `x1`; + a label present in both groups denotes the same cluster. In a paired + analysis the two label arrays must be identical, as the observations are + paired by position. + + When every observation is its own cluster this reduces exactly to + `compute_bootstrapped_diff`. + """ + from . import effsize as __es + + x0, x1 = np.asarray(x0), np.asarray(x1) + (c0, c1), n_clusters = cluster_codes(c0, c1) + if is_paired: + _check_paired_clusters(c0, c1) + + tables0 = cluster_tables(c0, n_clusters) + tables1 = cluster_tables(c1, n_clusters) + strata_clusters, strata_offsets = cluster_strata((c0, c1), n_clusters) + draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed) + + out = np.empty(resamples, dtype=np.float64) + for i in range(resamples): + idx0 = expand_cluster_draw(draws[i], *tables0) + idx1 = idx0 if is_paired else expand_cluster_draw(draws[i], *tables1) + out[i] = __es.two_group_difference(x0[idx0], x1[idx1], is_paired, effect_size) + + return out + + +def delta2_cluster_bootstrap_loop( + x1, x2, x3, x4, c1, c2, c3, c4, resamples, pooled_sd, rng_seed, is_paired, proportional=False +): + """ + Cluster-bootstrap counterpart of `delta2_bootstrap_loop`: whole clusters + are resampled with replacement, jointly across the four groups. + """ + xs = [np.asarray(x) for x in (x1, x2, x3, x4)] + (c1, c2, c3, c4), n_clusters = cluster_codes(c1, c2, c3, c4) + if is_paired: + _check_paired_clusters(c1, c2) + _check_paired_clusters(c3, c4) + + tables = [cluster_tables(c, n_clusters) for c in (c1, c2, c3, c4)] + strata_clusters, strata_offsets = cluster_strata((c1, c2, c3, c4), n_clusters) + draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, rng_seed) + + deltadelta = np.empty(resamples) + out_delta_g = np.empty(resamples) + + for i in range(resamples): + means = [np.mean(x[expand_cluster_draw(draws[i], *t)]) for x, t in zip(xs, tables)] + delta_delta = (means[3] - means[2]) - (means[1] - means[0]) + + deltadelta[i] = delta_delta + out_delta_g[i] = delta_delta if proportional else delta_delta / pooled_sd + + return out_delta_g, deltadelta + + +def delta2_cluster_variance_components(x1, x2, x3, x4, c1, c2, c3, c4, is_paired): + """ + Stratum-by-stratum jackknife variance components of the delta-delta + `(mean(x4) - mean(x3)) - (mean(x2) - mean(x1))`, for use with + `expanded_ci_level`. Delta g divides the delta-delta by a constant, which + leaves the relative size of the components, and so the expansion, + unchanged. + """ + xs = [np.asarray(x) for x in (x1, x2, x3, x4)] + codes, n_clusters = cluster_codes(c1, c2, c3, c4) + if is_paired: + _check_paired_clusters(codes[0], codes[1]) + _check_paired_clusters(codes[2], codes[3]) + + values, deleted = [], [] + for g in range(n_clusters): + keeps = [c != g for c in codes] + if not all(k.any() for k in keeps): + # Deleting this cluster would empty one of the groups. + continue + means = [x[k].mean() for x, k in zip(xs, keeps)] + values.append((means[3] - means[2]) - (means[1] - means[0])) + deleted.append(g) + return cluster_variance_components(values, deleted, codes, n_clusters) + + @njit(cache=True) def delta2_bootstrap_loop(x1, x2, x3, x4, resamples, pooled_sd, rng_seed, is_paired, proportional=False): """ @@ -211,18 +645,29 @@ def compute_delta2_bootstrapped_diff( is_paired: str = None, resamples: int = 5000, random_seed: int = 12345, - proportional: bool = False + proportional: bool = False, + clusters=None, # Optional: four array-likes with the cluster label of every observation in x1, x2, x3 and x4. ) -> tuple: """ - Bootstraps the effect size deltas' g or proportional delta-delta + Bootstraps the effect size deltas' g or proportional delta-delta. + + If `clusters` is supplied, whole clusters are resampled with replacement + (see `compute_cluster_bootstrapped_diff`) instead of individual observations. """ x1, x2, x3, x4 = map(np.asarray, [x1, x2, x3, x4]) + + def _bootstrap_loop(pooled_sd, is_proportional): + if clusters is None: + return delta2_bootstrap_loop( + x1, x2, x3, x4, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional + ) + return delta2_cluster_bootstrap_loop( + x1, x2, x3, x4, *clusters, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional + ) if proportional: # For proportional data, pass 1.0 as dummy pooled_sd (won't be used) - out_delta_g, deltadelta = delta2_bootstrap_loop( - x1, x2, x3, x4, resamples, 1.0, random_seed, is_paired, proportional=True - ) + out_delta_g, deltadelta = _bootstrap_loop(1.0, True) # For proportional data, delta_g is the empirical delta-delta delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1))) else: @@ -241,9 +686,7 @@ def compute_delta2_bootstrapped_diff( if np.isnan(pooled_sample_sd) or pooled_sample_sd == 0: raise ValueError("Pooled sample standard deviation is NaN or zero.") - out_delta_g, deltadelta = delta2_bootstrap_loop( - x1, x2, x3, x4, resamples, pooled_sample_sd, random_seed, is_paired, proportional=False - ) + out_delta_g, deltadelta = _bootstrap_loop(pooled_sample_sd, False) delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1))) / pooled_sample_sd return out_delta_g, delta_g, deltadelta diff --git a/dabest/_stats_tools/precompile.py b/dabest/_stats_tools/precompile.py index c0e0f2f9..c9ac90f1 100644 --- a/dabest/_stats_tools/precompile.py +++ b/dabest/_stats_tools/precompile.py @@ -44,7 +44,12 @@ def precompile_all(): (confint_2group_diff.delta2_bootstrap_loop, (dummy_control, dummy_test, dummy_control, dummy_test, 10, 1.0, 12345, False)), (confint_2group_diff._compute_quantile, (0.5, 0.1, 0.1)), - (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3)) + (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3)), + (confint_2group_diff.cluster_bootstrap_draws, + (np.array([0, 1, 2], dtype=np.int64), np.array([0, 3], dtype=np.int64), 10, 12345)), + (confint_2group_diff.expand_cluster_draw, + (np.array([0, 1], dtype=np.int64), np.array([0, 1, 3], dtype=np.int64), + np.array([0, 1, 2], dtype=np.int64))), ] for func, args in tqdm(funcs, desc="Compiling numba functions"): diff --git a/dabest/forest_plot.py b/dabest/forest_plot.py index eca7ed18..fb11f918 100644 --- a/dabest/forest_plot.py +++ b/dabest/forest_plot.py @@ -22,7 +22,8 @@ def load_plot_data( effect_size: str = "mean_diff", contrast_type: str = None, ci_type: str = "bca", - idx: Optional[List[int]] = None + idx: Optional[List[int]] = None, + include_unexpanded: bool = False, ) -> List: """ Loads plot data based on specified effect size and contrast type. @@ -40,11 +41,17 @@ def load_plot_data( idx: Optional[List[int]], default=None List of indices to select from the contrast objects if delta-delta experiment. If None, only the delta-delta objects are plotted. + include_unexpanded: bool, default False + If True, also return, for each curve, the `(low, high)` limits of its + interval before expansion for a small number of clusters, or + `(None, None)` if the interval was not expanded. Returns ------- List: Contrast plot data based on specified parameters. """ + from .plot_tools import unexpanded_limits + # Effect size and contrast types effect_attr = "hedges_g" if effect_size == 'delta_g' else effect_size contrast_attr = {"delta2": "delta_delta", "mini_meta": "mini_meta"}.get(contrast_type) @@ -52,6 +59,7 @@ def load_plot_data( # Testing if idx is not None: bootstraps, differences, bcalows, bcahighs = [], [], [], [] + unexpanded = [] for current_idx, index_group in enumerate(idx): current_contrast = data[current_idx] if len(index_group)>0: @@ -83,6 +91,7 @@ def load_plot_data( differences.append(current_plot_data.results.difference[index_val]) bcalows.append(current_plot_data.results.get(ci_type+'_low')[index_val]) bcahighs.append(current_plot_data.results.get(ci_type+'_high')[index_val]) + unexpanded.append(unexpanded_limits(current_plot_data.results, ci_type, index_val)) else: if contrast_type == 'delta': contrast_plot_data = [getattr(contrast, effect_attr) for contrast in data] @@ -95,6 +104,8 @@ def load_plot_data( differences = [element for innerList in differences_nested for element in innerList] bcalows = [element for innerList in bcalows_nested for element in innerList] bcahighs = [element for innerList in bcahighs_nested for element in innerList] + unexpanded = [unexpanded_limits(result.results, ci_type, i) + for result in contrast_plot_data for i in range(len(result.results))] else: # contrast_type == 'delta2' or 'mini_meta' contrast_plot_data = [getattr(getattr(contrast, effect_attr), contrast_attr) for contrast in data] @@ -104,7 +115,10 @@ def load_plot_data( differences = [result.difference for result in contrast_plot_data] bcalows = [result.results.get(ci_type+'_low')[0] for result in contrast_plot_data] bcahighs = [result.results.get(ci_type+'_high')[0] for result in contrast_plot_data] + unexpanded = [unexpanded_limits(result.results, ci_type, 0) for result in contrast_plot_data] + if include_unexpanded: + return bootstraps, differences, bcalows, bcahighs, unexpanded return bootstraps, differences, bcalows, bcahighs def check_for_errors(**kwargs): @@ -457,6 +471,7 @@ def forest_plot( zeroline_kwargs: Optional[dict] = None, marker_kwargs: Optional[dict] = None, errorbar_kwargs: Optional[dict] = None, + expanded_errorbar_kwargs: Optional[dict] = None, )-> plt.Figure: """ Custom function that generates a forest plot from given contrast objects, suitable for a range of data analysis types, including those from packages like DABEST-python. @@ -530,25 +545,33 @@ def forest_plot( Additional arguments for the effect size marker customization. errorbar_kwargs : Optional[dict], default=None Additional arguments for the effect size error bar customization. + expanded_errorbar_kwargs : Optional[dict], default=None + For intervals expanded for a small number of clusters (see + `dabest.load`'s `cluster_ci_expansion`), the unexpanded interval (the + nominal interval of the plotted bootstrap distribution) is drawn as the + usual error bar, and the expansion beyond it as a thinner line. Additional + arguments here style the thinner line; by default it takes the error + bar's arguments at 40% of its line width. Returns ------- plt.Figure The matplotlib figure object with the generated forest plot. """ - from .plot_tools import halfviolin + from .plot_tools import halfviolin, plot_ci_whisker, expanded_errorbar_kwargs_from # Check for errors in the input arguments all_kwargs = locals() contrast_type = check_for_errors(**all_kwargs) # Load plot data and extract info - bootstraps, differences, bcalows, bcahighs = load_plot_data( + bootstraps, differences, bcalows, bcahighs, unexpanded = load_plot_data( data = data, effect_size = effect_size, contrast_type = contrast_type, ci_type = ci_type, - idx = idx + idx = idx, + include_unexpanded = True, ) # Adjust figure size based on orientation number_of_curves_to_plot = len(bootstraps) @@ -585,13 +608,14 @@ def forest_plot( ) ## Plotting the effect sizes and confidence intervals + expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs, expanded_errorbar_kwargs) for k in range(1, number_of_curves_to_plot + 1): if horizontal: ax.plot(differences[k - 1], k, **marker_kwargs) - ax.plot([bcalows[k - 1], bcahighs[k - 1]], [k, k], **errorbar_kwargs) else: ax.plot(k, differences[k - 1], **marker_kwargs) - ax.plot([k, k], [bcalows[k - 1], bcahighs[k - 1]], **errorbar_kwargs) + plot_ci_whisker(ax, k, bcalows[k - 1], bcahighs[k - 1], horizontal, errorbar_kwargs, + unexpanded[k - 1][0], unexpanded[k - 1][1], expanded_errorbar_kwargs) # Aesthetic Adjustments ## Handle the custom color palette diff --git a/dabest/misc_tools.py b/dabest/misc_tools.py index 4060b7ca..deec82e1 100644 --- a/dabest/misc_tools.py +++ b/dabest/misc_tools.py @@ -700,20 +700,52 @@ def get_color_palette( return (color_col, bootstraps_color_by_group, n_groups, filled, raw_colors, plot_palette_raw, plot_palette_contrast, plot_palette_sankey) +def _tick_label_gap_inches(n_lines: int, fontsize) -> float: + """ + Vertical gap, in inches, that keeps `n_lines` of tick labels at `fontsize` + on the upper (raw data) axes clear of the lower (contrast) axes: the text, + plus room for the tick marks and a small margin. + """ + from matplotlib.font_manager import FontProperties + + size_pt = FontProperties(size=fontsize).get_size_in_points() + return (n_lines * 1.2 * size_pt + 14) / 72 + + +def _hspace_for_tick_labels( + n_lines: int, + fontsize, + available_height: float, + minimum: float, + ) -> float: + """ + Vertical gap, as a fraction of each axes' height, that keeps multi-line + tick labels on the upper (raw data) axes clear of the lower (contrast) axes. + + `available_height` is the height in inches shared by both axes and the gap + between them (see `_tick_label_gap_inches`). Never returns less than `minimum`. + """ + needed = _tick_label_gap_inches(n_lines, fontsize) + # Axes heights h and gap g satisfy 2h + g = available_height and g = hspace * h. + remaining = max(available_height - needed, 0.25 * available_height) + return max(minimum, 2 * needed / remaining) + + def initialize_fig( - plot_kwargs: dict, - dabest_obj: object, - show_delta2: bool, - show_mini_meta: bool, - is_paired: bool, - show_pairs: bool, + plot_kwargs: dict, + dabest_obj: object, + show_delta2: bool, + show_mini_meta: bool, + is_paired: bool, + show_pairs: bool, proportional: bool, float_contrast: bool, - effect_size_type: str, - yvar: str, - horizontal: bool, + effect_size_type: str, + yvar: str, + horizontal: bool, show_table: bool, color_col: str, + two_col_sankey: bool = False, ): """ Initialize the figure and axes for the plotter function. @@ -746,6 +778,9 @@ def initialize_fig( A boolean flag to determine if the table will be shown in horizontal plot. color_col : str The column name for coloring the data points. + two_col_sankey : bool, default False + Whether the plot is a two-column (non-flow) Sankey diagram, whose raw + data tick labels span several lines. """ # Params fig_size = plot_kwargs["fig_size"] @@ -786,6 +821,18 @@ def initialize_fig( width_ratios_ga = [2.5, 1] h_space_cummings = (0.1 if plot_kwargs["gridkey"] is not None else 0.3) + # Cluster-aware sample-size labels add a line to each raw-data tick label + # (see `add_counts_to_ticks`), on top of the two lines of an ordinary label + # or the four of a two-column Sankey label. In that case the gap between the + # raw data and contrast axes is sized to the labels, so they clear the + # contrast axes below. + size_gap_to_labels = ( + plot_kwargs["gridkey"] is None + and plot_kwargs["show_sample_size"] + and getattr(dabest_obj, "cluster_col", None) is not None + ) + n_label_lines = (4 if two_col_sankey else 2) + 1 + fontsize_rawxlabel = plot_kwargs.get("fontsize_rawxlabel") if plot_kwargs["ax"] is not None: # New in v0.2.6. @@ -835,6 +882,30 @@ def initialize_fig( ) contrast_axes = axins + elif size_gap_to_labels: + # The contrast axes hangs a fixed distance below the raw data + # axes, sized to the tick labels, rather than a fraction of the + # axes' height: a layout engine that later resizes the raw data + # axes (e.g. with `figure.autolayout`) would otherwise stretch + # the gap along with it. + fig_height = fig.get_figheight() + available = (ax_position.y1 - ax_position.y0) * fig_height # inches + gap = max(min(_tick_label_gap_inches(n_label_lines, fontsize_rawxlabel), 0.75 * available), + h_space_cummings * available / (2 + h_space_cummings)) + plot_height = (available - gap) / 2 + axins = rawdata_axes.inset_axes( + [0, -1, 1, 1], + transform=rawdata_axes.transAxes + + matplotlib.transforms.ScaledTranslation(0, -gap, fig.dpi_scale_trans), + ) + rawdata_axes.set_position( + [ + ax_position.x0, + ax_position.y0 + (plot_height + gap) / fig_height, + (ax_position.x1 - ax_position.x0), + plot_height / fig_height, + ] + ) else: axins = rawdata_axes.inset_axes([0, -1 - h_space_cummings, 1, 1]) plot_height = (ax_position.y1 - ax_position.y0) / (2 + h_space_cummings) @@ -871,6 +942,15 @@ def initialize_fig( **init_fig_kwargs ) else: + if size_gap_to_labels: + subplot_height = (plt.rcParams["figure.subplot.top"] + - plt.rcParams["figure.subplot.bottom"]) + h_space_cummings = _hspace_for_tick_labels( + n_label_lines, + fontsize_rawxlabel, + fig_size[1] * subplot_height, + h_space_cummings, + ) fig, axx = plt.subplots( nrows=2, gridspec_kw={"hspace": h_space_cummings}, **init_fig_kwargs ) @@ -1027,13 +1107,14 @@ def get_plot_groups( def add_counts_to_ticks( - plot_data: pd.DataFrame, - xvar: str, - yvar: str, - rawdata_axes: axes.Axes, - plot_kwargs: dict, - flow: bool, - horizontal: bool + plot_data: pd.DataFrame, + xvar: str, + yvar: str, + rawdata_axes: axes.Axes, + plot_kwargs: dict, + flow: bool, + horizontal: bool, + cluster_col: str = None ): """ @@ -1055,24 +1136,33 @@ def add_counts_to_ticks( Whether sankey flow is enabled or not. horizontal : bool A boolean flag to determine if the plot is for horizontal plotting. + cluster_col : str, default None + Name of the column identifying the cluster (e.g. participant) each + observation belongs to, as declared to `dabest.load()`. When supplied, + each group's label also reports the number of distinct clusters + contributing to that group, on its own line below the observation + count, since that is the count the cluster-aware bootstrap actually + resamples. """ # Add the counts to the rawdata axes xticks. counts = plot_data.groupby(xvar, observed=False).count()[yvar] - - def lookup_value(text): + if cluster_col is not None: + cluster_counts = plot_data.groupby(xvar, observed=False)[cluster_col].nunique() + + def lookup_value(series, text): try: - return str(counts.loc[text]) + return str(series.loc[text]) except KeyError: try: numeric_key = pd.to_numeric(text, errors='coerce') if pd.notnull(numeric_key): - return str(counts.loc[numeric_key]) + return str(series.loc[numeric_key]) except (ValueError, KeyError): pass print(f"Key '{text}' not found in counts.") return "N/A" - + ticks_with_counts = [] if horizontal: get_label, get_ticks = rawdata_axes.get_yticklabels, rawdata_axes.get_yticks @@ -1080,7 +1170,7 @@ def lookup_value(text): else: get_label, get_ticks = rawdata_axes.get_xticklabels, rawdata_axes.get_xticks set_label, set_major_loc_method = rawdata_axes.set_xticklabels, rawdata_axes.xaxis.set_major_locator - + for ticklab in get_label(): t = ticklab.get_text() @@ -1089,11 +1179,17 @@ def lookup_value(text): else: te = t.split('\n')[-1] # Get the last line of the label - value = lookup_value(te) + value = lookup_value(counts, te) + if cluster_col is not None: + n_clusters = lookup_value(cluster_counts, te) + count_text = "(N={},\n n={})".format(value, n_clusters) + else: + count_text = "(N={})".format(value) + if horizontal: - ticks_with_counts.append(f"{t} (N={value})") + ticks_with_counts.append(f"{t} {count_text}") else: - ticks_with_counts.append(f"{t}\n(N={value})") + ticks_with_counts.append(f"{t}\n{count_text}") set_major_loc_method(plt.FixedLocator(get_ticks())) diff --git a/dabest/plot_tools.py b/dabest/plot_tools.py index 9fa023f1..be244540 100644 --- a/dabest/plot_tools.py +++ b/dabest/plot_tools.py @@ -10,8 +10,9 @@ # %% auto #0 __all__ = ['halfviolin', 'get_swarm_spans', 'error_bar', 'check_data_matches_labels', 'normalize_dict', 'width_determine', 'single_sankey', 'sankeydiag', 'add_bars_to_plot', 'delta_text_plotter', 'delta_dots_plotter', - 'slopegraph_plotter', 'plot_minimeta_or_deltadelta_violins', 'effect_size_curve_plotter', 'gridkey_plotter', - 'barplotter', 'table_for_horizontal_plots', 'add_counts_to_prop_plots', 'swarmplot', 'SwarmPlot'] + 'slopegraph_plotter', 'plot_minimeta_or_deltadelta_violins', 'unexpanded_limits', 'plot_ci_whisker', + 'expanded_errorbar_kwargs_from', 'effect_size_curve_plotter', 'gridkey_plotter', 'barplotter', + 'table_for_horizontal_plots', 'add_counts_to_prop_plots', 'swarmplot', 'SwarmPlot'] # %% ../nbs/API/plot_tools.ipynb #b070950d import math @@ -1248,8 +1249,9 @@ def plot_minimeta_or_deltadelta_violins( plot_kwargs: dict, horizontal: bool, show_pairs: bool, - contrast_marker_kwargs: dict, + contrast_marker_kwargs: dict, contrast_errorbar_kwargs: dict, + contrast_expanded_errorbar_kwargs: dict = None, ): """ Add mini meta-analysis or delta-delta violin plots to the contrast plot. @@ -1282,6 +1284,9 @@ def plot_minimeta_or_deltadelta_violins( Keyword arguments for the effectsize marker. contrast_errorbar_kwargs: dict Keyword arguments for the effectsize errorbar. + contrast_expanded_errorbar_kwargs : dict, default None + Keyword arguments for the thin line showing how far the interval was + expanded for a small number of clusters (see `plot_ci_whisker`). """ # Plot the curve @@ -1304,12 +1309,10 @@ def extract_curve_data(dabest_object): position = max(rawdata_axes.get_yticks()) + 1 half = "bottom" effsize_x, effsize_y = difference, [position] - ci_x, ci_y = [ci_low, ci_high], [position, position] else: position = max(rawdata_axes.get_xticks()) + 1 half = "right" effsize_x, effsize_y = [position], difference - ci_x, ci_y = [position, position], [ci_low, ci_high] v = contrast_axes.violinplot( data[~np.isinf(data)], positions=[position], **contrast_kwargs @@ -1324,11 +1327,9 @@ def extract_curve_data(dabest_object): **contrast_marker_kwargs ) # Plot the confidence interval. - contrast_axes.plot( - ci_x, - ci_y, - **contrast_errorbar_kwargs - ) + unexpanded_low, unexpanded_high = unexpanded_limits(dabest_obj.results, ci_type, 0) + plot_ci_whisker(contrast_axes, position, ci_low, ci_high, horizontal, contrast_errorbar_kwargs, + unexpanded_low, unexpanded_high, contrast_expanded_errorbar_kwargs) # Add labels and ticks if horizontal: @@ -1373,23 +1374,109 @@ def extract_curve_data(dabest_object): return delta2_axes, contrast_xtick_labels +def unexpanded_limits(results: pd.DataFrame, prefix: str, index: int): + """ + The unexpanded interval limits stored in `results` for row `index`, e.g. + `bca_low_unexpanded` and `bca_high_unexpanded` for `prefix="bca"`, or + `(None, None)` if the interval was not expanded for a small number of clusters. + """ + low = results.get(prefix + "_low_unexpanded") + high = results.get(prefix + "_high_unexpanded") + if low is None or high is None: + return None, None + low, high = low[index], high[index] + if pd.isna(low) or pd.isna(high): + return None, None + return low, high + + +def plot_ci_whisker( + ax: axes.Axes, + position: float, + ci_low: float, + ci_high: float, + horizontal: bool, + errorbar_kwargs: dict, + unexpanded_low: float = None, + unexpanded_high: float = None, + expanded_errorbar_kwargs: dict = None, + ): + """ + Draw a confidence interval at `position` on `ax`. + + When the interval has been expanded for a small number of clusters, the + unexpanded limits are given too. The unexpanded interval, which the plotted + bootstrap distribution itself spans, is then drawn as the usual thick bar, + and the expansion beyond it as a thinner line (styled by + `expanded_errorbar_kwargs`), so that the plot shows which part of the + interval comes from resampling and which is the small-sample allowance. + + Parameters + ---------- + ax : axes.Axes + Matplotlib axis object to plot on. + position : float + The tick at which to draw the interval. + ci_low, ci_high : float + The limits of the reported interval. + horizontal : bool + If the plot is horizontal. + errorbar_kwargs : dict + Keyword arguments for the interval line. + unexpanded_low, unexpanded_high : float, default None + The limits before expansion, if the interval was expanded. + expanded_errorbar_kwargs : dict, default None + Keyword arguments for the thinner line showing the expansion. + """ + def segment(low, high, kwargs): + if horizontal: + ax.plot([low, high], [position, position], **kwargs) + else: + ax.plot([position, position], [low, high], **kwargs) + + if unexpanded_low is None or unexpanded_high is None: + segment(ci_low, ci_high, errorbar_kwargs) + return + if expanded_errorbar_kwargs is None: + expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs) + segment(ci_low, ci_high, expanded_errorbar_kwargs) + segment(unexpanded_low, unexpanded_high, errorbar_kwargs) + + +def expanded_errorbar_kwargs_from(errorbar_kwargs: dict, custom_kwargs: dict = None) -> dict: + """ + Keyword arguments for the thin line that shows the expansion of an + interval for a small number of clusters: those of the interval line, at + 40% of its width (at least 0.75 points), updated with `custom_kwargs`. + """ + kwargs = dict(errorbar_kwargs) + width = kwargs.pop("linewidth", kwargs.pop("lw", 2)) + kwargs["lw"] = max(0.75, 0.4 * width) + if custom_kwargs: + if "linewidth" in custom_kwargs: + kwargs.pop("lw") + kwargs.update(custom_kwargs) + return kwargs + + def effect_size_curve_plotter( - ticks_to_plot: list, - ticks_for_baseline_ec: list, - results: pd.DataFrame, - ci_type: str, - contrast_axes: axes.Axes, - contrast_kwargs: dict, - bootstraps_color_by_group: bool, + ticks_to_plot: list, + ticks_for_baseline_ec: list, + results: pd.DataFrame, + ci_type: str, + contrast_axes: axes.Axes, + contrast_kwargs: dict, + bootstraps_color_by_group: bool, plot_palette_contrast: dict, - horizontal: bool, - contrast_marker_kwargs: dict, + horizontal: bool, + contrast_marker_kwargs: dict, contrast_errorbar_kwargs: dict, - idx: list, - is_paired: bool, - contrast_paired_lines: bool, + idx: list, + is_paired: bool, + contrast_paired_lines: bool, contrast_paired_lines_kwargs: dict, - show_baseline_ec: bool = False + show_baseline_ec: bool = False, + contrast_expanded_errorbar_kwargs: dict = None, ): """ Add effect size curves to the contrast plot. @@ -1428,9 +1515,13 @@ def effect_size_curve_plotter( Keyword arguments for the repeated measures lines. show_baseline_ec : bool Whether to show the baseline effect curve. + contrast_expanded_errorbar_kwargs : dict, default None + Keyword arguments for the thin line showing how far an interval was + expanded for a small number of clusters (see `plot_ci_whisker`). """ - def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): + def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high, + unexpanded=(None, None)): # Create the violinplot if horizontal: contrast_kwargs.update({'orientation': 'horizontal', 'widths': 1}) @@ -1447,13 +1538,9 @@ def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): halfviolin(v, fill_color=fc, alpha=contrast_alpha, half=half) # Plot the confidence interval - if horizontal: - ci_x, ci_y = [ci_low, ci_high], [tick, tick] - else: - ci_x, ci_y = [tick, tick], [ci_low, ci_high] - - contrast_axes.plot(ci_x, ci_y, **contrast_errorbar_kwargs) - + plot_ci_whisker(contrast_axes, tick, ci_low, ci_high, horizontal, contrast_errorbar_kwargs, + unexpanded[0], unexpanded[1], contrast_expanded_errorbar_kwargs) + return "{}\nminus\n{}".format(group, control) if contrast_kwargs.get('alpha') is not None: @@ -1482,7 +1569,8 @@ def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): ) label = plot_effect_size(tick, current_group, current_control, current_bootstrap, - current_effsize, current_ci_low, current_ci_high) + current_effsize, current_ci_low, current_ci_high, + unexpanded_limits(results, ci_type, int(j))) contrast_xtick_labels.append(label) # Add baseline effect curve plotting @@ -1504,8 +1592,9 @@ def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high): contrast_axes.plot(effsize_x, effsize_y, **contrast_marker_kwargs) if show_baseline_ec: - _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap, - bec_effsize, bec_ci_low, bec_ci_high) + _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap, + bec_effsize, bec_ci_low, bec_ci_high, + unexpanded_limits(bec_results, 'bec_' + ci_type, j)) # Baseline Curve doesn't need tick text # Add lines for repeated measures data diff --git a/dabest/plotter.py b/dabest/plotter.py index f40685c8..620f1351 100644 --- a/dabest/plotter.py +++ b/dabest/plotter.py @@ -77,6 +77,7 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi gridkey_delimiters=[';', '>', '_'], gridkey_kwargs=None, contrast_marker_kwargs=None, contrast_errorbar_kwargs=None, + contrast_expanded_errorbar_kwargs=None, prop_sample_counts=False, prop_sample_counts_kwargs=None, contrast_paired_lines=True, contrast_paired_lines show_baseline_ec=False, @@ -112,7 +113,8 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi barplotter, table_for_horizontal_plots, add_counts_to_prop_plots, - add_bars_to_plot + add_bars_to_plot, + expanded_errorbar_kwargs_from, ) warnings.filterwarnings( @@ -180,7 +182,8 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi yvar = yvar, horizontal = horizontal, show_table = table_kwargs['show'], - color_col = color_col + color_col = color_col, + two_col_sankey = two_col_sankey, ) # Plotting the rawdata. @@ -314,13 +317,14 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi # Add the counts to the rawdata axes xticks. if show_sample_size: add_counts_to_ticks( - plot_data = plot_data, - xvar = xvar, - yvar = yvar, - rawdata_axes = rawdata_axes, + plot_data = plot_data, + xvar = xvar, + yvar = yvar, + rawdata_axes = rawdata_axes, plot_kwargs = plot_kwargs, flow = sankey_kwargs["flow"], horizontal = horizontal, + cluster_col = dabest_obj.cluster_col, ) # Add counts to prop plots (embedded in the plot bars) @@ -378,6 +382,11 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi ticks_to_plot = [x+0.25 for x in ticks_to_plot] ## Plot the bootstraps, then the effect sizes and CIs. + # Intervals expanded for a small number of clusters are drawn as a thick bar + # over the unexpanded interval and a thinner line over the expansion. + contrast_expanded_errorbar_kwargs = expanded_errorbar_kwargs_from( + contrast_errorbar_kwargs, plot_kwargs.get("contrast_expanded_errorbar_kwargs") + ) contrast_paired_lines = False if float_contrast or not sankey_kwargs["flow"] else plot_kwargs["contrast_paired_lines"] (current_group, current_control, current_effsize, contrast_xtick_labels) = effect_size_curve_plotter( @@ -397,6 +406,7 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi contrast_paired_lines = contrast_paired_lines, contrast_paired_lines_kwargs = contrast_paired_lines_kwargs, show_baseline_ec = show_baseline_ec, + contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs, ) ## Plot mini-meta or delta-delta violin @@ -416,6 +426,7 @@ def effectsize_df_plotter(effectsize_df: object, **plot_kwargs) -> matplotlib.fi show_pairs = show_pairs, contrast_marker_kwargs = contrast_marker_kwargs, contrast_errorbar_kwargs = contrast_errorbar_kwargs, + contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs, ) ## Contrast bars contrast_bars = plot_kwargs["contrast_bars"] diff --git a/nbs/API/confint_2group_diff.ipynb b/nbs/API/confint_2group_diff.ipynb index bdc009b3..adb13a47 100644 --- a/nbs/API/confint_2group_diff.ipynb +++ b/nbs/API/confint_2group_diff.ipynb @@ -214,6 +214,436 @@ " return out\n", "\n", "\n", + "def cluster_codes(*cluster_labels):\n", + " \"\"\"\n", + " Convert cluster labels from one or more groups into contiguous integer codes.\n", + "\n", + " The labels of all groups are pooled, so that the same label appearing in\n", + " several groups (e.g. a participant measured under every condition) maps\n", + " to the same code. Codes are assigned in order of first appearance.\n", + "\n", + " Returns\n", + " -------\n", + " codes : list of int64 numpy arrays, one per input group.\n", + " n_clusters : int\n", + " The number of distinct clusters across all groups.\n", + " \"\"\"\n", + " import pandas as pd\n", + "\n", + " arrays = [np.asarray(a) for a in cluster_labels]\n", + " joined = np.concatenate(arrays) if len(arrays) > 1 else arrays[0]\n", + " codes, uniques = pd.factorize(pd.Series(joined), sort=False)\n", + " codes = codes.astype(np.int64)\n", + " if (codes < 0).any():\n", + " raise ValueError(\"Cluster labels must not contain missing values.\")\n", + "\n", + " out, start = [], 0\n", + " for a in arrays:\n", + " out.append(codes[start : start + len(a)])\n", + " start += len(a)\n", + " return out, len(uniques)\n", + "\n", + "\n", + "def cluster_tables(codes, n_clusters):\n", + " \"\"\"\n", + " Build the membership tables used by `expand_cluster_draw`.\n", + "\n", + " Returns `(offsets, members)` such that `members[offsets[g]:offsets[g+1]]`\n", + " holds the positions (in the original array) of the observations that\n", + " belong to cluster `g`. A cluster absent from the array has an empty slice.\n", + " \"\"\"\n", + " codes = np.asarray(codes, dtype=np.int64)\n", + " members = np.argsort(codes, kind=\"stable\").astype(np.int64)\n", + " counts = np.bincount(codes, minlength=n_clusters)\n", + " offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64)\n", + " return offsets, members\n", + "\n", + "\n", + "def cluster_strata(codes_per_group, n_clusters):\n", + " \"\"\"\n", + " Partition the clusters into resampling strata.\n", + "\n", + " Clusters are stratified by the pattern of groups in which they appear, so\n", + " that every bootstrap resample preserves the observed design. For a fully\n", + " within-cluster design (every cluster present in every group) there is a\n", + " single stratum and clusters are resampled jointly across the groups; for a\n", + " nested design (each cluster present in one group only) the clusters are\n", + " resampled separately within each group.\n", + "\n", + " Returns `(strata_clusters, strata_offsets)`: the cluster codes concatenated\n", + " stratum by stratum, and the boundaries of each stratum in that array.\n", + " \"\"\"\n", + " pattern = np.zeros(n_clusters, dtype=np.int64)\n", + " for k, codes in enumerate(codes_per_group):\n", + " present = np.zeros(n_clusters, dtype=bool)\n", + " present[np.asarray(codes, dtype=np.int64)] = True\n", + " pattern |= present.astype(np.int64) << k\n", + "\n", + " strata_clusters = np.argsort(pattern, kind=\"stable\").astype(np.int64)\n", + " _, counts = np.unique(pattern, return_counts=True)\n", + " strata_offsets = np.concatenate((np.zeros(1, dtype=np.int64), np.cumsum(counts))).astype(np.int64)\n", + " return strata_clusters, strata_offsets\n", + "\n", + "\n", + "@njit(cache=True) # parallelization must be turned off for random number generation\n", + "def cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed):\n", + " \"\"\"\n", + " Draw clusters with replacement, separately within each stratum\n", + " (see `cluster_strata`).\n", + "\n", + " Returns an array of shape `(resamples, n_clusters)` holding, for each\n", + " resample, the codes of the clusters drawn.\n", + " \"\"\"\n", + " np.random.seed(random_seed)\n", + " n_clusters = len(strata_clusters)\n", + " n_strata = len(strata_offsets) - 1\n", + " draws = np.empty((resamples, n_clusters), dtype=np.int64)\n", + "\n", + " for i in range(resamples):\n", + " for s in range(n_strata):\n", + " start = strata_offsets[s]\n", + " size = strata_offsets[s + 1] - start\n", + " picks = np.random.choice(size, size)\n", + " for k in range(size):\n", + " draws[i, start + k] = strata_clusters[start + picks[k]]\n", + " return draws\n", + "\n", + "\n", + "@njit(cache=True)\n", + "def expand_cluster_draw(draw, offsets, members):\n", + " \"\"\"\n", + " Expand a draw of cluster codes into the positions of all the observations\n", + " that belong to those clusters (see `cluster_tables`).\n", + " \"\"\"\n", + " total = 0\n", + " for j in range(len(draw)):\n", + " g = draw[j]\n", + " total += offsets[g + 1] - offsets[g]\n", + "\n", + " out = np.empty(total, dtype=np.int64)\n", + " pos = 0\n", + " for j in range(len(draw)):\n", + " g = draw[j]\n", + " for k in range(offsets[g], offsets[g + 1]):\n", + " out[pos] = members[k]\n", + " pos += 1\n", + " return out\n", + "\n", + "\n", + "def _check_paired_clusters(c0, c1):\n", + " \"\"\"Paired observations must share a cluster.\"\"\"\n", + " if len(c0) != len(c1) or not np.array_equal(c0, c1):\n", + " err1 = \"In a paired analysis every control observation must belong to the same cluster \"\n", + " err2 = \"as the test observation it is paired with. Check that the data are sorted so \"\n", + " err3 = \"that paired rows are aligned, and that each pair has a single cluster label.\"\n", + " raise ValueError(err1 + err2 + err3)\n", + "\n", + "\n", + "def compute_cluster_jackknife(x0, x1, c0, c1, is_paired, effect_size):\n", + " \"\"\"\n", + " Delete-one-cluster jackknife of the effect size for 2 groups.\n", + "\n", + " Used to compute the acceleration term of the BCa interval when the\n", + " observations are clustered. `c0` and `c1` hold the cluster label of each\n", + " observation in `x0` and `x1`.\n", + " \"\"\"\n", + " values, _, _, _ = cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size)\n", + " return values\n", + "\n", + "\n", + "def cluster_jackknife_by_cluster(x0, x1, c0, c1, is_paired, effect_size):\n", + " \"\"\"\n", + " Delete-one-cluster jackknife of the effect size for 2 groups, keeping track\n", + " of which cluster each jackknife value leaves out.\n", + "\n", + " Returns `(values, deleted_codes, (codes0, codes1), n_clusters)`, where\n", + " `values[i]` is the effect size with cluster `deleted_codes[i]` removed, and\n", + " `codes0`/`codes1` are the integer cluster codes of the observations in\n", + " `x0`/`x1` (see `cluster_codes`). Clusters whose removal would empty a group\n", + " are skipped.\n", + " \"\"\"\n", + " from . import effsize as __es\n", + "\n", + " x0, x1 = np.asarray(x0), np.asarray(x1)\n", + " (c0, c1), n_clusters = cluster_codes(c0, c1)\n", + " if is_paired:\n", + " _check_paired_clusters(c0, c1)\n", + "\n", + " values, deleted = [], []\n", + " for g in range(n_clusters):\n", + " keep0 = c0 != g\n", + " keep1 = c1 != g\n", + " if not keep0.any() or not keep1.any():\n", + " # Deleting this cluster would empty one of the groups.\n", + " continue\n", + " values.append(__es.two_group_difference(x0[keep0], x1[keep1], is_paired, effect_size))\n", + " deleted.append(g)\n", + " return values, deleted, (c0, c1), n_clusters\n", + "\n", + "\n", + "def cluster_variance_components(jackknife_values, deleted_codes, codes_per_group, n_clusters):\n", + " \"\"\"\n", + " Split the delete-one-cluster jackknife variance of an estimate into the\n", + " contributions of the resampling strata (see `cluster_strata`).\n", + "\n", + " Returns a list of `(variance, n)` pairs, one per stratum of `n` clusters,\n", + " where `variance` is that stratum's term of the stratified jackknife\n", + " variance estimate. Strata with fewer than 2 clusters are left out: the\n", + " cluster bootstrap cannot vary them, and they carry no information about\n", + " the number of degrees of freedom. Non-finite jackknife values are ignored.\n", + " \"\"\"\n", + " strata_clusters, strata_offsets = cluster_strata(codes_per_group, n_clusters)\n", + " value_of = {g: v for g, v in zip(deleted_codes, jackknife_values) if np.isfinite(v)}\n", + "\n", + " components = []\n", + " for s in range(len(strata_offsets) - 1):\n", + " members = strata_clusters[strata_offsets[s] : strata_offsets[s + 1]]\n", + " n = len(members)\n", + " if n < 2:\n", + " continue\n", + " values = np.array([value_of[g] for g in members if g in value_of], dtype=float)\n", + " if len(values) < 2:\n", + " continue\n", + " variance = (n - 1) / n * np.sum((values - values.mean()) ** 2)\n", + " components.append((float(variance), int(n)))\n", + " return components\n", + "\n", + "\n", + "# The smallest tail probability an expanded interval is read at. It keeps the\n", + "# quantile functions finite; any value this small already selects the extreme\n", + "# bootstrap resamples for any practical number of resamples.\n", + "_MIN_EXPANDED_ALPHA = 1e-6\n", + "\n", + "# Strata carrying less than this share of the variance are not counted when\n", + "# judging whether the smallest group of clusters is too small for a reliable\n", + "# interval (see `smallest_cluster_group`), so that a stray handful of clusters\n", + "# (say, two participants seen in only one condition) does not trigger a warning.\n", + "_MIN_VARIANCE_SHARE = 0.1\n", + "\n", + "\n", + "def _usable_components(components):\n", + " \"\"\"Strata with at least 2 clusters, as arrays of variances and sizes.\"\"\"\n", + " components = [(v, n) for v, n in components if n >= 2]\n", + " if not components:\n", + " return None, None\n", + " variances = np.array([v for v, _ in components], dtype=float)\n", + " n = np.array([n for _, n in components], dtype=float)\n", + " if not np.all(np.isfinite(variances)) or variances.sum() <= 0:\n", + " # No usable variance information: weight the strata equally.\n", + " variances = np.ones_like(n)\n", + " return variances, n\n", + "\n", + "\n", + "def smallest_cluster_group(components):\n", + " \"\"\"\n", + " The number of clusters in the smallest stratum that carries at least 10%\n", + " of the variance (see `cluster_variance_components`); None if no stratum\n", + " has at least 2 clusters.\n", + " \"\"\"\n", + " variances, n = _usable_components(components)\n", + " if n is None:\n", + " return None\n", + " shares = variances / variances.sum()\n", + " # Never let the threshold exclude every stratum (e.g. many equal strata).\n", + " threshold = min(_MIN_VARIANCE_SHARE, shares.max())\n", + " return int(n[shares >= threshold].min())\n", + "\n", + "\n", + "def expanded_ci_level(ci, components):\n", + " \"\"\"\n", + " The confidence level at which to read a cluster-bootstrap distribution so\n", + " that the resulting interval has approximately `ci`% coverage when there\n", + " are few clusters.\n", + "\n", + " Bootstrap intervals are too narrow when there are few independent units:\n", + " the bootstrap reproduces a variance with divisor `n` rather than `n - 1`,\n", + " and normal rather than t-distributed tails. This applies the expanded\n", + " percentile correction of Hesterberg (2015, The American Statistician,\n", + " 69(4), 371-386) with the number of clusters as `n`: the interval is read\n", + " at the level whose normal quantile equals `sqrt(n/(n-1))` times the\n", + " t quantile with `n - 1` degrees of freedom.\n", + "\n", + " When the bootstrap resamples several strata independently (for example\n", + " clusters nested within groups), `components` holds each stratum's\n", + " `(variance, n)` (see `cluster_variance_components`). The narrowness\n", + " correction is then applied stratum by stratum, weighted by each stratum's\n", + " share of the variance, and the degrees of freedom come from the\n", + " Welch-Satterthwaite approximation. Both reduce to the single-sample\n", + " correction above for one stratum. In simulations of unbalanced or mixed\n", + " designs whose smallest group held only 4 to 6 clusters, Welch-Satterthwaite\n", + " intervals covered 1 to 3 points below nominal; the more conservative\n", + " alternative of the smallest stratum's degrees of freedom over-covered by\n", + " similar amounts, with intervals about 10% wider.\n", + "\n", + " Returns `(ci_expanded, df)`, or `(ci, None)` if no stratum has at least\n", + " 2 clusters, in which case no expansion is possible.\n", + " \"\"\"\n", + " from scipy.stats import t as student_t\n", + "\n", + " variances, n = _usable_components(components)\n", + " if n is None:\n", + " return ci, None\n", + "\n", + " total = variances.sum()\n", + " narrowness = np.sqrt(total / np.sum(variances * (n - 1) / n))\n", + " df = float(total ** 2 / np.sum(variances ** 2 / (n - 1)))\n", + "\n", + " alpha = _compute_alpha_from_ci(ci)\n", + " z = narrowness * student_t.ppf(1 - alpha / 2, df)\n", + " alpha_expanded = max(2 * norm.sf(z), _MIN_EXPANDED_ALPHA)\n", + " return 100 * (1 - alpha_expanded), float(df)\n", + "\n", + "\n", + "def percentile_interval_idx(ci, n_boots):\n", + " \"\"\"\n", + " Indexes of the percentile interval limits in a sorted array of `n_boots`\n", + " bootstrap values, kept within the array.\n", + " \"\"\"\n", + " alpha = _compute_alpha_from_ci(ci)\n", + " low = int((alpha / 2) * n_boots)\n", + " high = int((1 - alpha / 2) * n_boots)\n", + " return min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", + "\n", + "\n", + "def unexpanded_interval_limits(sorted_bootstraps, bias, acceleration, ci):\n", + " \"\"\"\n", + " The BCa and percentile limits at the nominal level `ci`, as\n", + " `(bca_low, bca_high, pct_low, pct_high)`, for an interval that has been\n", + " expanded for a small number of clusters. Plots show this unexpanded\n", + " interval, which the bootstrap distribution itself spans, as the thick part\n", + " of the interval, and the expansion beyond it as a thinner line. If the BCa\n", + " limits cannot be computed, the percentile limits are used for both.\n", + " \"\"\"\n", + " n_boots = len(sorted_bootstraps)\n", + " pct_low, pct_high = percentile_interval_idx(ci, n_boots)\n", + " low, high = compute_interval_limits(bias, acceleration, n_boots, ci)\n", + " if isnan(low) or isnan(high):\n", + " low, high = pct_low, pct_high\n", + " else:\n", + " low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", + " return (sorted_bootstraps[low], sorted_bootstraps[high],\n", + " sorted_bootstraps[pct_low], sorted_bootstraps[pct_high])\n", + "\n", + "\n", + "def expanded_interval_limits(bias, acceleration, n_boots, ci_expanded):\n", + " \"\"\"\n", + " Indexes of the BCa interval limits at the expanded level `ci_expanded`\n", + " (see `expanded_ci_level`), kept within the array of bootstrap values.\n", + "\n", + " Returns `(nan, nan)` if the BCa adjustment is undefined at this level,\n", + " which can happen when a large acceleration meets a very extreme level;\n", + " callers should then fall back to the expanded percentile interval.\n", + " \"\"\"\n", + " alpha = _compute_alpha_from_ci(ci_expanded)\n", + " for z in (norm.ppf(alpha / 2), norm.ppf(1 - alpha / 2)):\n", + " if not np.isfinite(bias) or not np.isfinite(acceleration) or 1 - acceleration * (bias + z) <= 0:\n", + " return np.nan, np.nan\n", + "\n", + " low, high = compute_interval_limits(bias, acceleration, n_boots, ci_expanded)\n", + " if isnan(low) or isnan(high):\n", + " return np.nan, np.nan\n", + " low, high = min(max(low, 0), n_boots - 1), min(max(high, 0), n_boots - 1)\n", + " if low > high:\n", + " return np.nan, np.nan\n", + " return low, high\n", + "\n", + "\n", + "def compute_cluster_bootstrapped_diff(\n", + " x0, x1, c0, c1, is_paired, effect_size, resamples=5000, random_seed=12345\n", + "):\n", + " \"\"\"\n", + " Cluster bootstrap of the effect size for 2 groups.\n", + "\n", + " Instead of resampling individual observations (or pairs), whole clusters\n", + " of observations (e.g. all the observations contributed by one participant)\n", + " are resampled with replacement, so that the correlation between\n", + " observations from the same cluster is preserved in every resample.\n", + "\n", + " `c0` and `c1` hold the cluster label of each observation in `x0` and `x1`;\n", + " a label present in both groups denotes the same cluster. In a paired\n", + " analysis the two label arrays must be identical, as the observations are\n", + " paired by position.\n", + "\n", + " When every observation is its own cluster this reduces exactly to\n", + " `compute_bootstrapped_diff`.\n", + " \"\"\"\n", + " from . import effsize as __es\n", + "\n", + " x0, x1 = np.asarray(x0), np.asarray(x1)\n", + " (c0, c1), n_clusters = cluster_codes(c0, c1)\n", + " if is_paired:\n", + " _check_paired_clusters(c0, c1)\n", + "\n", + " tables0 = cluster_tables(c0, n_clusters)\n", + " tables1 = cluster_tables(c1, n_clusters)\n", + " strata_clusters, strata_offsets = cluster_strata((c0, c1), n_clusters)\n", + " draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, random_seed)\n", + "\n", + " out = np.empty(resamples, dtype=np.float64)\n", + " for i in range(resamples):\n", + " idx0 = expand_cluster_draw(draws[i], *tables0)\n", + " idx1 = idx0 if is_paired else expand_cluster_draw(draws[i], *tables1)\n", + " out[i] = __es.two_group_difference(x0[idx0], x1[idx1], is_paired, effect_size)\n", + "\n", + " return out\n", + "\n", + "\n", + "def delta2_cluster_bootstrap_loop(\n", + " x1, x2, x3, x4, c1, c2, c3, c4, resamples, pooled_sd, rng_seed, is_paired, proportional=False\n", + "):\n", + " \"\"\"\n", + " Cluster-bootstrap counterpart of `delta2_bootstrap_loop`: whole clusters\n", + " are resampled with replacement, jointly across the four groups.\n", + " \"\"\"\n", + " xs = [np.asarray(x) for x in (x1, x2, x3, x4)]\n", + " (c1, c2, c3, c4), n_clusters = cluster_codes(c1, c2, c3, c4)\n", + " if is_paired:\n", + " _check_paired_clusters(c1, c2)\n", + " _check_paired_clusters(c3, c4)\n", + "\n", + " tables = [cluster_tables(c, n_clusters) for c in (c1, c2, c3, c4)]\n", + " strata_clusters, strata_offsets = cluster_strata((c1, c2, c3, c4), n_clusters)\n", + " draws = cluster_bootstrap_draws(strata_clusters, strata_offsets, resamples, rng_seed)\n", + "\n", + " deltadelta = np.empty(resamples)\n", + " out_delta_g = np.empty(resamples)\n", + "\n", + " for i in range(resamples):\n", + " means = [np.mean(x[expand_cluster_draw(draws[i], *t)]) for x, t in zip(xs, tables)]\n", + " delta_delta = (means[3] - means[2]) - (means[1] - means[0])\n", + "\n", + " deltadelta[i] = delta_delta\n", + " out_delta_g[i] = delta_delta if proportional else delta_delta / pooled_sd\n", + "\n", + " return out_delta_g, deltadelta\n", + "\n", + "\n", + "def delta2_cluster_variance_components(x1, x2, x3, x4, c1, c2, c3, c4, is_paired):\n", + " \"\"\"\n", + " Stratum-by-stratum jackknife variance components of the delta-delta\n", + " `(mean(x4) - mean(x3)) - (mean(x2) - mean(x1))`, for use with\n", + " `expanded_ci_level`. Delta g divides the delta-delta by a constant, which\n", + " leaves the relative size of the components, and so the expansion,\n", + " unchanged.\n", + " \"\"\"\n", + " xs = [np.asarray(x) for x in (x1, x2, x3, x4)]\n", + " codes, n_clusters = cluster_codes(c1, c2, c3, c4)\n", + " if is_paired:\n", + " _check_paired_clusters(codes[0], codes[1])\n", + " _check_paired_clusters(codes[2], codes[3])\n", + "\n", + " values, deleted = [], []\n", + " for g in range(n_clusters):\n", + " keeps = [c != g for c in codes]\n", + " if not all(k.any() for k in keeps):\n", + " # Deleting this cluster would empty one of the groups.\n", + " continue\n", + " means = [x[k].mean() for x, k in zip(xs, keeps)]\n", + " values.append((means[3] - means[2]) - (means[1] - means[0]))\n", + " deleted.append(g)\n", + " return cluster_variance_components(values, deleted, codes, n_clusters)\n", + "\n", + "\n", "@njit(cache=True)\n", "def delta2_bootstrap_loop(x1, x2, x3, x4, resamples, pooled_sd, rng_seed, is_paired, proportional=False):\n", " \"\"\"\n", @@ -263,18 +693,29 @@ " is_paired: str = None,\n", " resamples: int = 5000,\n", " random_seed: int = 12345,\n", - " proportional: bool = False\n", + " proportional: bool = False,\n", + " clusters=None, # Optional: four array-likes with the cluster label of every observation in x1, x2, x3 and x4.\n", ") -> tuple:\n", " \"\"\"\n", - " Bootstraps the effect size deltas' g or proportional delta-delta\n", + " Bootstraps the effect size deltas' g or proportional delta-delta.\n", + "\n", + " If `clusters` is supplied, whole clusters are resampled with replacement\n", + " (see `compute_cluster_bootstrapped_diff`) instead of individual observations.\n", " \"\"\"\n", " x1, x2, x3, x4 = map(np.asarray, [x1, x2, x3, x4])\n", + "\n", + " def _bootstrap_loop(pooled_sd, is_proportional):\n", + " if clusters is None:\n", + " return delta2_bootstrap_loop(\n", + " x1, x2, x3, x4, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional\n", + " )\n", + " return delta2_cluster_bootstrap_loop(\n", + " x1, x2, x3, x4, *clusters, resamples, pooled_sd, random_seed, is_paired, proportional=is_proportional\n", + " )\n", " \n", " if proportional:\n", " # For proportional data, pass 1.0 as dummy pooled_sd (won't be used)\n", - " out_delta_g, deltadelta = delta2_bootstrap_loop(\n", - " x1, x2, x3, x4, resamples, 1.0, random_seed, is_paired, proportional=True\n", - " )\n", + " out_delta_g, deltadelta = _bootstrap_loop(1.0, True)\n", " # For proportional data, delta_g is the empirical delta-delta\n", " delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1)))\n", " else:\n", @@ -293,9 +734,7 @@ " if np.isnan(pooled_sample_sd) or pooled_sample_sd == 0:\n", " raise ValueError(\"Pooled sample standard deviation is NaN or zero.\")\n", " \n", - " out_delta_g, deltadelta = delta2_bootstrap_loop(\n", - " x1, x2, x3, x4, resamples, pooled_sample_sd, random_seed, is_paired, proportional=False\n", - " )\n", + " out_delta_g, deltadelta = _bootstrap_loop(pooled_sample_sd, False)\n", " delta_g = ((np.mean(x4) - np.mean(x3)) - (np.mean(x2) - np.mean(x1))) / pooled_sample_sd\n", "\n", " return out_delta_g, delta_g, deltadelta\n", diff --git a/nbs/API/dabest_object.ipynb b/nbs/API/dabest_object.ipynb index f082c62b..f1c0a0a8 100644 --- a/nbs/API/dabest_object.ipynb +++ b/nbs/API/dabest_object.ipynb @@ -144,6 +144,8 @@ " x1_level,\n", " mini_meta,\n", " ps_adjust,\n", + " cluster_col=None,\n", + " cluster_ci_expansion=True,\n", " ):\n", " \"\"\"\n", " Parses and stores pandas DataFrames in preparation for estimation\n", @@ -163,6 +165,8 @@ " self.__is_proportional = proportional\n", " self.__is_mini_meta = mini_meta\n", " self.__ps_adjust = ps_adjust\n", + " self.__cluster_col = cluster_col\n", + " self.__cluster_ci_expansion = cluster_ci_expansion\n", "\n", " # after this call the attributes self.__experiment_label and self.__x1_level are updated\n", " self._check_errors(x, y, idx, experiment, experiment_label, x1_level)\n", @@ -231,6 +235,16 @@ " resamples_line2 = \"will be used to generate the effect size bootstraps.\"\n", " out.append(resamples_line1 + resamples_line2)\n", "\n", + " if self.__cluster_col is not None:\n", + " cluster_line1 = \"Whole clusters, as defined by `{}`, \".format(self.__cluster_col)\n", + " cluster_line2 = \"will be resampled by the bootstrap and reshuffled by the permutation test.\"\n", + " out.append(cluster_line1 + cluster_line2)\n", + " if self.__cluster_ci_expansion:\n", + " out.append(\n", + " \"Confidence intervals will be expanded for the number of clusters \"\n", + " \"(set `cluster_ci_expansion=False` to turn this off).\"\n", + " )\n", + "\n", " return \"\\n\".join(out)\n", "\n", "\n", @@ -445,6 +459,23 @@ " return self.__id_col\n", "\n", " @property\n", + " def cluster_col(self):\n", + " \"\"\"\n", + " Returns the cluster column declared to `dabest.load()`, if any.\n", + " When set, the bootstrap resamples whole clusters of observations and\n", + " the permutation test reshuffles labels at the cluster level.\n", + " \"\"\"\n", + " return self.__cluster_col\n", + "\n", + " @property\n", + " def cluster_ci_expansion(self):\n", + " \"\"\"\n", + " Returns whether confidence intervals of clustered data are expanded for\n", + " a small number of clusters, as declared to `dabest.load()`.\n", + " \"\"\"\n", + " return self.__cluster_ci_expansion\n", + "\n", + " @property\n", " def ci(self):\n", " \"\"\"\n", " The width of the desired confidence interval.\n", @@ -685,6 +716,33 @@ " if self.__id_col not in self.__output_data.columns:\n", " err = \"`id_col` was given as '{}'; however, '{}' is not a column in `data`.\".format(self.__id_col, self.__id_col)\n", " raise IndexError(err)\n", + "\n", + " # Check if `cluster_ci_expansion` is valid\n", + " if not isinstance(self.__cluster_ci_expansion, (bool, np.bool_)):\n", + " raise TypeError(\"`cluster_ci_expansion` must be True or False.\")\n", + "\n", + " # Check if `cluster_col` is valid\n", + " if self.__cluster_col is not None:\n", + " if self.__cluster_col not in self.__output_data.columns:\n", + " err = \"`cluster_col` was given as '{}'; however, '{}' is not a column in `data`.\".format(self.__cluster_col, self.__cluster_col)\n", + " raise IndexError(err)\n", + "\n", + " if y is not None and self.__cluster_col == y:\n", + " err = \"`cluster_col` cannot be the same column as `y`.\"\n", + " raise ValueError(err)\n", + "\n", + " x_columns = x if isinstance(x, (list, tuple)) else [x]\n", + " if self.__cluster_col in x_columns:\n", + " err1 = \"`cluster_col` cannot be the same column as `x`: every group would \"\n", + " err2 = \"then be a single cluster, leaving nothing to resample.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", + " if x is None and idx is not None:\n", + " # Wide format: the cluster column cannot also be one of the groups.\n", + " groups = [g for item in idx for g in (item if isinstance(item, (tuple, list)) else (item,))]\n", + " if self.__cluster_col in groups:\n", + " err = \"`cluster_col` ('{}') cannot also be one of the groups in `idx`.\".format(self.__cluster_col)\n", + " raise ValueError(err)\n", " \n", " # Check if x and y are supplied (relevant to long format data)\n", " if x is None and y is not None:\n", @@ -780,8 +838,32 @@ " plot_data[self.__xvar], categories=all_plot_groups, ordered=True\n", " )\n", "\n", + " if self.__cluster_col is not None:\n", + " self._check_clusters(plot_data)\n", + "\n", " return plot_data\n", "\n", + " def _check_clusters(self, plot_data):\n", + " \"\"\"\n", + " Check that the cluster labels are complete and, for paired data,\n", + " consistent within each `id_col` value.\n", + " \"\"\"\n", + " clusters = plot_data[self.__cluster_col]\n", + " if clusters.isnull().any():\n", + " err1 = \"`cluster_col` ('{}') contains missing values.\".format(self.__cluster_col)\n", + " err2 = \" Every observation must belong to a cluster.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", + " if self.__is_paired:\n", + " clusters_per_id = plot_data.groupby(self.__id_col, observed=True)[self.__cluster_col].nunique()\n", + " inconsistent = clusters_per_id.index[clusters_per_id > 1].tolist()\n", + " if inconsistent:\n", + " err1 = \"Each value of `id_col` must belong to a single cluster in `cluster_col`,\"\n", + " err2 = \" but the following values of '{}' have more than one cluster label: {}.\".format(\n", + " self.__id_col, inconsistent[:10]\n", + " )\n", + " raise ValueError(err1 + err2)\n", + "\n", " def _compute_effectsize_dfs(self):\n", " '''\n", " Function to compute all attributes based on EffectSizeDataFrame.\n", @@ -801,6 +883,7 @@ " x2=self.__x2,\n", " mini_meta=self.__is_mini_meta,\n", " ps_adjust=self.__ps_adjust,\n", + " cluster_ci_expansion=self.__cluster_ci_expansion,\n", " )\n", "\n", " self.__mean_diff = EffectSizeDataFrame(\n", diff --git a/nbs/API/delta_objects.ipynb b/nbs/API/delta_objects.ipynb index 91656b16..05e95235 100644 --- a/nbs/API/delta_objects.ipynb +++ b/nbs/API/delta_objects.ipynb @@ -120,6 +120,29 @@ "outputs": [], "source": [ "#| export\n", + "def _bca_interval_idx(bias, acceleration, resamples, ci, ci_expanded=None):\n", + " \"\"\"\n", + " Indexes of the BCa interval limits. When `ci_expanded` is given (the\n", + " interval is expanded for a small number of clusters), the interval is read\n", + " at that level; if the BCa adjustment is undefined there, the expanded\n", + " percentile limits are used instead.\n", + " \"\"\"\n", + " from ._stats_tools import confint_2group_diff as ci2g\n", + "\n", + " if ci_expanded is None:\n", + " return ci2g.compute_interval_limits(bias, acceleration, resamples, ci)\n", + "\n", + " low, high = ci2g.expanded_interval_limits(bias, acceleration, resamples, ci_expanded)\n", + " if (isnan(low) or isnan(high)) and np.isfinite(bias):\n", + " warnings.warn(\n", + " \"The bias-corrected and accelerated adjustment is undefined at the \"\n", + " \"expanded confidence level; the expanded percentile interval is \"\n", + " \"reported in its place.\"\n", + " )\n", + " low, high = ci2g.percentile_interval_idx(ci_expanded, resamples)\n", + " return low, high\n", + "\n", + "\n", "class DeltaDelta(object):\n", " r\"\"\"\n", " A class to compute and store the delta-delta statistics for experiments with a 2-by-2 arrangement where two independent variables, A and B, each have two categorical values, 1 and 2. The data is divided into two pairs of two groups, and a primary delta is first calculated as the mean difference between each of the pairs:\n", @@ -150,7 +173,8 @@ " \"\"\"\n", "\n", " def __init__(\n", - " self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95\n", + " self, effectsizedataframe, permutation_count, bootstraps_delta_delta, ci=95,\n", + " ci_expanded=None,\n", " ):\n", " from ._stats_tools import effsize as es\n", " from ._stats_tools import confint_1group as ci1g\n", @@ -159,6 +183,9 @@ " self.__effsizedf = effectsizedataframe.results\n", " self.__dabest_obj = effectsizedataframe.dabest_obj\n", " self.__ci = ci\n", + " # The level at which the bootstrap distribution is read when the interval\n", + " # is expanded for a small number of clusters (see `expanded_ci_level`).\n", + " self.__ci_expanded = ci_expanded\n", " self.__resamples = effectsizedataframe.resamples\n", " self.__effect_size = effectsizedataframe.effect_size\n", " self.__alpha = ci2g._compute_alpha_from_ci(ci)\n", @@ -190,8 +217,9 @@ " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", - " self.__bias_correction, self.__acceleration_value, self.__resamples, ci\n", + " bca_idx_low, bca_idx_high = _bca_interval_idx(\n", + " self.__bias_correction, self.__acceleration_value, self.__resamples, ci,\n", + " self.__ci_expanded,\n", " )\n", "\n", " self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n", @@ -230,13 +258,22 @@ " warnings.warn(err_temp.substitute(lim_type=\"upper\"), stacklevel=0)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n", - " pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples\n", + " )\n", "\n", " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_delta_delta[pct_idx_low]\n", " self.__pct_high = sorted_delta_delta[pct_idx_high]\n", "\n", + " # For an expanded interval, keep the unexpanded limits too: plots draw\n", + " # them as the thick part of the interval.\n", + " self.__unexpanded = (None, None, None, None)\n", + " if self.__ci_expanded is not None:\n", + " self.__unexpanded = ci2g.unexpanded_interval_limits(\n", + " sorted_delta_delta, self.__bias_correction, self.__acceleration_value, ci\n", + " )\n", + "\n", " def __permutation_test(self):\n", " \"\"\"\n", " Perform a permutation test and obtain the permutation p-value\n", @@ -291,8 +328,14 @@ " pvalue = p1 + p2\n", "\n", " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", - " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", - " bs = bs1 + bs2\n", + " bs2 = \"the confidence interval is bias-corrected and accelerated\"\n", + " if self.__ci_expanded is not None:\n", + " bs1 = \"{} cluster bootstrap samples were taken; \".format(self.__resamples)\n", + " bs2 += (\n", + " \", and expanded for the small number of clusters\\n(the {}% interval is \"\n", + " \"read at the {:.2f}% level of the bootstrap distribution)\".format(ci_width, self.__ci_expanded)\n", + " )\n", + " bs = bs1 + bs2 + \".\"\n", "\n", " pval_def1 = (\n", " \"Any p-value reported is the probability of observing the \"\n", @@ -323,11 +366,16 @@ " # With some inspiration from @jungyangliao\n", " delta_delta_results_df = pd.Series(self.to_dict()).to_frame().T\n", "\n", - " column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx', \n", - " 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test', \n", + " column_index = ['control', 'test', 'difference', 'ci', 'bca_low', 'bca_high', 'bca_interval_idx',\n", + " 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps_control', 'bootstraps_test',\n", " 'bootstraps_delta_delta', 'permutations_control', 'permutations_test', 'permutations_delta_delta',\n", " 'pvalue_permutation', 'permutation_count', 'bias_correction', 'jackknives'\n", " ]\n", + " if self.__ci_expanded is not None:\n", + " column_index.insert(column_index.index('ci') + 1, 'ci_expanded')\n", + " position = column_index.index('pct_interval_idx') + 1\n", + " column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded',\n", + " 'pct_low_unexpanded', 'pct_high_unexpanded']\n", " delta_delta_results_df['bootstraps_control'] = [delta_delta_results_df['bootstraps'][0][0]]\n", " delta_delta_results_df['bootstraps_test'] = [delta_delta_results_df['bootstraps'][0][1]]\n", " delta_delta_results_df['permutations_control'] = [delta_delta_results_df['permutations'][0][0]]\n", @@ -345,6 +393,47 @@ " return self.__ci\n", "\n", " @property\n", + " def ci_expanded(self):\n", + " \"\"\"\n", + " The confidence level, in percent, at which the cluster-bootstrap\n", + " distribution was read so that the reported `ci`% interval allows for a\n", + " small number of clusters. None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__ci_expanded\n", + "\n", + " @property\n", + " def bca_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa lower\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[0]\n", + "\n", + " @property\n", + " def bca_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa upper\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[1]\n", + "\n", + " @property\n", + " def pct_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " lower limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[2]\n", + "\n", + " @property\n", + " def pct_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " upper limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[3]\n", + "\n", + " @property\n", " def alpha(self):\n", " \"\"\"\n", " Returns the significance level of the statistical test as a float\n", @@ -638,6 +727,24 @@ " \n", " self.__bootstraps_variance = ci2g.calculate_bootstraps_var(self.__bootstraps)\n", "\n", + " # Expand the interval for a small number of clusters. The weighted delta\n", + " # averages the experiments' deltas with weights w_j, so experiment j\n", + " # contributes (w_j / sum(w))^2 of its own variance; its stratum\n", + " # components are scaled accordingly and combined across experiments.\n", + " self.__ci_expanded = None\n", + " if (getattr(self.__dabest_obj, \"cluster_col\", None) is not None\n", + " and getattr(effectsizedataframe, \"cluster_ci_expansion\", False)):\n", + " per_experiment = effectsizedataframe._expansion_components\n", + " if all(c is not None for c in per_experiment):\n", + " weights = 1 / self.__bootstraps_variance\n", + " shares = weights / weights.sum()\n", + " combined = [(v * share ** 2, n)\n", + " for components, share in zip(per_experiment, shares)\n", + " for v, n in components]\n", + " level, df = ci2g.expanded_ci_level(ci, combined)\n", + " if df is not None:\n", + " self.__ci_expanded = level\n", + "\n", " # Compute the weighted average mean differences of the bootstrap data\n", " # using the pooled group variances of the raw data as the inverse of \n", " # weights\n", @@ -662,9 +769,9 @@ " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", + " bca_idx_low, bca_idx_high = _bca_interval_idx(\n", " self.__bias_correction, self.__acceleration_value,\n", - " self.__resamples, ci)\n", + " self.__resamples, ci, self.__ci_expanded)\n", " \n", " self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n", "\n", @@ -704,12 +811,20 @@ " stacklevel=0)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha/2) * self.__resamples)\n", - " pct_idx_high = int((1-(self.__alpha/2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " self.__ci_expanded if self.__ci_expanded is not None else ci, self.__resamples)\n", "\n", " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_weighted_deltas[pct_idx_low]\n", " self.__pct_high = sorted_weighted_deltas[pct_idx_high]\n", + "\n", + " # For an expanded interval, keep the unexpanded limits too: plots draw\n", + " # them as the thick part of the interval.\n", + " self.__unexpanded = (None, None, None, None)\n", + " if self.__ci_expanded is not None:\n", + " self.__unexpanded = ci2g.unexpanded_interval_limits(\n", + " sorted_weighted_deltas, self.__bias_correction, self.__acceleration_value, ci\n", + " )\n", " \n", " \n", "\n", @@ -785,8 +900,14 @@ "\n", "\n", " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", - " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", - " bs = bs1 + bs2\n", + " bs2 = \"the confidence interval is bias-corrected and accelerated\"\n", + " if self.__ci_expanded is not None:\n", + " bs1 = \"{} cluster bootstrap samples were taken; \".format(self.__resamples)\n", + " bs2 += (\n", + " \", and expanded for the small number of clusters\\n(the {}% interval is \"\n", + " \"read at the {:.2f}% level of the bootstrap distribution)\".format(ci_width, self.__ci_expanded)\n", + " )\n", + " bs = bs1 + bs2 + \".\"\n", "\n", " pval_def1 = \"Any p-value reported is the probability of observing the\" + \\\n", " \"effect size (or greater),\\nassuming the null hypothesis of \" + \\\n", @@ -825,6 +946,11 @@ " 'pct_low', 'pct_high', 'pct_interval_idx', 'bootstraps', 'bootstraps_weighted_delta', \n", " 'permutations', 'permutations_var', 'permutations_weighted_delta', 'pvalue_permutation', \n", " 'permutation_count', 'bias_correction', 'jackknives']\n", + " if self.__ci_expanded is not None:\n", + " column_index.insert(column_index.index('ci') + 1, 'ci_expanded')\n", + " position = column_index.index('pct_interval_idx') + 1\n", + " column_index[position:position] = ['bca_low_unexpanded', 'bca_high_unexpanded',\n", + " 'pct_low_unexpanded', 'pct_high_unexpanded']\n", " mini_meta_delta_results_df = mini_meta_delta_results_df.reindex(columns=column_index)\n", " mini_meta_delta_results_df.rename(columns={'bootstraps': 'bootstraps_deltas'}, inplace=True)\n", "\n", @@ -839,6 +965,47 @@ " \"\"\"\n", " return self.__ci\n", "\n", + " @property\n", + " def ci_expanded(self):\n", + " \"\"\"\n", + " The confidence level, in percent, at which the cluster-bootstrap\n", + " distribution was read so that the reported `ci`% interval allows for a\n", + " small number of clusters. None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__ci_expanded\n", + "\n", + " @property\n", + " def bca_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa lower\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[0]\n", + "\n", + " @property\n", + " def bca_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa upper\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[1]\n", + "\n", + " @property\n", + " def pct_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " lower limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[2]\n", + "\n", + " @property\n", + " def pct_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " upper limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__unexpanded[3]\n", + "\n", "\n", " @property\n", " def alpha(self):\n", diff --git a/nbs/API/effsize_objects.ipynb b/nbs/API/effsize_objects.ipynb index 22fe2412..09d3647c 100644 --- a/nbs/API/effsize_objects.ipynb +++ b/nbs/API/effsize_objects.ipynb @@ -153,6 +153,21 @@ " ps_adjust : boolean, default False.\n", " If True, adjust calculated p-value according to Phipson & Smyth (2010)\n", " # https://doi.org/10.2202/1544-6115.1585\n", + " control_clusters : array-like, default None\n", + " test_clusters : array-like, default None\n", + " The cluster (e.g. participant) that each observation in `control`\n", + " and `test` belongs to. When supplied, the bootstrap resamples whole\n", + " clusters with replacement and the permutation test reshuffles\n", + " labels at the cluster level, so that the confidence interval and\n", + " permutation p-value account for the correlation between\n", + " observations from the same cluster. A label present in both\n", + " arrays denotes the same cluster. For paired data the two arrays\n", + " must be identical, since observations are paired by position.\n", + " cluster_ci_expansion : boolean, default True\n", + " Only used when clusters are supplied. If True, the confidence\n", + " intervals are expanded for a small number of clusters (see\n", + " `dabest.load`); if False, the unexpanded cluster-bootstrap\n", + " intervals are reported.\n", " \n", "\n", " Returns\n", @@ -178,6 +193,10 @@ " The bias-corrected and accelerated confidence interval lower limit and upper limits, respectively.\n", " `pct_low, pct_high` : float\n", " The percentile confidence interval lower limit and upper limits, respectively.\n", + " `ci_expanded` : float or None\n", + " For clustered data, the confidence level at which the bootstrap\n", + " distribution was read so that the reported `ci`% intervals allow for\n", + " a small number of clusters; None if the intervals were not expanded.\n", " \"\"\"\n", "\n", " def __init__(\n", @@ -192,6 +211,9 @@ " permutation_count=5000,\n", " random_seed=12345,\n", " ps_adjust=False,\n", + " control_clusters=None,\n", + " test_clusters=None,\n", + " cluster_ci_expansion=True,\n", " ):\n", " from ._stats_tools import confint_2group_diff as ci2g\n", " from ._stats_tools import effsize as es\n", @@ -212,7 +234,11 @@ " self.__ci = ci\n", " self.__is_proportional = proportional\n", " self.__ps_adjust = ps_adjust\n", - " self._check_errors(control, test)\n", + " self.__is_clustered = control_clusters is not None or test_clusters is not None\n", + " if not isinstance(cluster_ci_expansion, (bool, np.bool_)):\n", + " raise TypeError(\"`cluster_ci_expansion` must be True or False.\")\n", + " self.__cluster_ci_expansion = bool(cluster_ci_expansion)\n", + " self._check_errors(control, test, control_clusters, test_clusters)\n", "\n", " # Convert to numpy arrays for speed.\n", " # NaNs are automatically dropped.\n", @@ -222,26 +248,77 @@ " self.__test = test[~isnan(test)]\n", " self.__permutation_count = permutation_count\n", "\n", + " if self.__is_clustered:\n", + " # Keep the cluster labels aligned with the NaN-filtered observations.\n", + " self.__control_clusters = array(control_clusters)[~isnan(control)]\n", + " self.__test_clusters = array(test_clusters)[~isnan(test)]\n", + " (control_codes, test_codes), self.__n_clusters = ci2g.cluster_codes(\n", + " self.__control_clusters, self.__test_clusters\n", + " )\n", + " if self.__is_paired and not np.array_equal(control_codes, test_codes):\n", + " err1 = \"In a paired analysis every control observation must belong to the same \"\n", + " err2 = \"cluster as the test observation it is paired with. Check that the data \"\n", + " err3 = \"are sorted so that paired rows are aligned, and that each pair has a single cluster label.\"\n", + " raise ValueError(err1 + err2 + err3)\n", + " else:\n", + " self.__control_clusters = None\n", + " self.__test_clusters = None\n", + " self.__n_clusters = None\n", + "\n", " self.__alpha = ci2g._compute_alpha_from_ci(self.__ci)\n", "\n", " self.__difference = es.two_group_difference(\n", " self.__control, self.__test, self.__is_paired, self.__effect_size\n", " )\n", "\n", - " self.__jackknives = ci2g.compute_meandiff_jackknife(\n", - " self.__control, self.__test, self.__is_paired, self.__effect_size\n", - " )\n", + " if self.__is_clustered:\n", + " jackknives, deleted, codes, n_codes = ci2g.cluster_jackknife_by_cluster(\n", + " self.__control,\n", + " self.__test,\n", + " self.__control_clusters,\n", + " self.__test_clusters,\n", + " self.__is_paired,\n", + " self.__effect_size,\n", + " )\n", + " self.__jackknives = jackknives\n", + " # How the jackknife variance splits across the resampling strata,\n", + " # used to expand the interval for small numbers of clusters.\n", + " self.__expansion_components = ci2g.cluster_variance_components(\n", + " jackknives, deleted, codes, n_codes\n", + " )\n", + " else:\n", + " self.__jackknives = ci2g.compute_meandiff_jackknife(\n", + " self.__control, self.__test, self.__is_paired, self.__effect_size\n", + " )\n", + " self.__expansion_components = None\n", "\n", " self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n", "\n", - " bootstraps = ci2g.compute_bootstrapped_diff(\n", - " self.__control,\n", - " self.__test,\n", - " self.__is_paired,\n", - " self.__effect_size,\n", - " self.__resamples,\n", - " self.__random_seed,\n", + " # Small-sample expansion of the interval for clustered data.\n", + " self.__ci_expanded, self.__expansion_df = self._expanded_level(\n", + " self.__expansion_components\n", " )\n", + "\n", + " if self.__is_clustered:\n", + " bootstraps = ci2g.compute_cluster_bootstrapped_diff(\n", + " self.__control,\n", + " self.__test,\n", + " self.__control_clusters,\n", + " self.__test_clusters,\n", + " self.__is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", + " else:\n", + " bootstraps = ci2g.compute_bootstrapped_diff(\n", + " self.__control,\n", + " self.__test,\n", + " self.__is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", " self.__bootstraps = bootstraps\n", "\n", " sorted_bootstraps = npsort(self.__bootstraps)\n", @@ -267,13 +344,25 @@ " self._compute_bca_intervals(sorted_bootstraps)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n", - " pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " self._interval_level(), self.__resamples\n", + " )\n", "\n", " self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__pct_low = sorted_bootstraps[pct_idx_low]\n", " self.__pct_high = sorted_bootstraps[pct_idx_high]\n", - " \n", + "\n", + " # For an expanded interval, keep the unexpanded limits too: plots draw\n", + " # them as the thick part of the interval.\n", + " if self.__ci_expanded is not None:\n", + " (self.__bca_low_unexpanded, self.__bca_high_unexpanded,\n", + " self.__pct_low_unexpanded, self.__pct_high_unexpanded) = ci2g.unexpanded_interval_limits(\n", + " sorted_bootstraps, self.__bias_correction, self.__acceleration_value, self.__ci\n", + " )\n", + " else:\n", + " self.__bca_low_unexpanded = self.__bca_high_unexpanded = None\n", + " self.__pct_low_unexpanded = self.__pct_high_unexpanded = None\n", + "\n", " self._get_bootstrap_baseline_ec()\n", "\n", " self._perform_statistical_test()\n", @@ -317,25 +406,44 @@ "\n", " pval_rounded = base_string_fmt.format(self.pvalue_permutation)\n", "\n", - " p1 = \"The p-value of the two-sided permutation t-test is {}, \".format(\n", - " pval_rounded\n", - " )\n", + " if self.__is_clustered:\n", + " p1 = \"The p-value of the two-sided cluster-level permutation test is {}, \".format(\n", + " pval_rounded\n", + " )\n", + " bs1 = \"{} cluster bootstrap samples were taken, resampling {} clusters with replacement; \".format(\n", + " self.__resamples, self.__n_clusters\n", + " )\n", + " else:\n", + " p1 = \"The p-value of the two-sided permutation t-test is {}, \".format(\n", + " pval_rounded\n", + " )\n", + " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", " p2 = \"calculated for legacy purposes only. \"\n", " pvalue = p1 + p2\n", "\n", - " bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n", - " bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n", - " bs = bs1 + bs2\n", + " bs2 = \"the confidence interval is bias-corrected and accelerated\"\n", + " if self.__ci_expanded is not None:\n", + " bs2 += (\n", + " \", and expanded for the small number of clusters\\n(the {}% interval is \"\n", + " \"read at the {:.2f}% level of the bootstrap distribution)\".format(ci_width, self.__ci_expanded)\n", + " )\n", + " bs = bs1 + bs2 + \".\"\n", "\n", " pval_def1 = (\n", " \"Any p-value reported is the probability of observing the\"\n", " + \"effect size (or greater),\\nassuming the null hypothesis of \"\n", " + \"zero difference is true.\"\n", " )\n", - " pval_def2 = (\n", - " \"\\nFor each p-value, 5000 reshuffles of the \"\n", - " + \"control and test labels were performed.\"\n", - " )\n", + " if self.__is_clustered:\n", + " pval_def2 = (\n", + " \"\\nFor each p-value, 5000 reshuffles of the control and test labels \"\n", + " + \"were performed at the level of whole clusters.\"\n", + " )\n", + " else:\n", + " pval_def2 = (\n", + " \"\\nFor each p-value, 5000 reshuffles of the \"\n", + " + \"control and test labels were performed.\"\n", + " )\n", " pval_def = pval_def1 + pval_def2\n", "\n", " if show_resample_count and define_pval:\n", @@ -347,10 +455,20 @@ " else:\n", " return \"{}\\n{}\".format(out, pvalue)\n", "\n", - " def _check_errors(self, control, test):\n", + " def _check_errors(self, control, test, control_clusters=None, test_clusters=None):\n", " '''\n", " Function to check configuration errors for the given control and test data.\n", " '''\n", + " if self.__is_clustered:\n", + " if control_clusters is None or test_clusters is None:\n", + " err1 = \"Both `control_clusters` and `test_clusters` must be supplied \"\n", + " err2 = \"for a cluster-aware analysis.\"\n", + " raise ValueError(err1 + err2)\n", + " if len(control_clusters) != len(control) or len(test_clusters) != len(test):\n", + " err1 = \"`control_clusters` and `test_clusters` must have the same lengths \"\n", + " err2 = \"as `control` and `test` respectively.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " kosher_es = [a for a in self.__EFFECT_SIZE_DICT.keys()]\n", " if self.__effect_size not in kosher_es:\n", " err1 = \"The effect size '{}'\".format(self.__effect_size)\n", @@ -373,18 +491,77 @@ " )\n", " raise ValueError(err1)\n", "\n", - " def _compute_bca_intervals(self, sorted_bootstraps):\n", + " def _expanded_level(self, components):\n", " '''\n", - " Function to compute the bca intervals given the sorted bootstraps.\n", + " The level at which to read the cluster-bootstrap distribution, expanded\n", + " for small numbers of clusters, and its degrees of freedom. Returns\n", + " `(None, None)` when the interval is not expanded.\n", " '''\n", " from ._stats_tools import confint_2group_diff as ci2g\n", "\n", + " if not (self.__is_clustered and self.__cluster_ci_expansion):\n", + " return None, None\n", + "\n", + " ci_expanded, df = ci2g.expanded_ci_level(self.__ci, components)\n", + " if df is None:\n", + " warnings.warn(\n", + " \"There are too few clusters (fewer than 2 in every resampling stratum) \"\n", + " \"to expand the confidence interval for a small number of clusters; \"\n", + " \"the unexpanded interval is reported, and it will be too narrow.\"\n", + " )\n", + " return None, None\n", + " # In simulations, expanded intervals came close to nominal coverage once\n", + " # there were at least 6 clusters in all, and at least 4 in the smallest\n", + " # independently resampled group of clusters.\n", + " n_total = sum(n for _, n in components if n >= 2)\n", + " n_smallest = ci2g.smallest_cluster_group(components)\n", + " if n_total < 6 or n_smallest < 4:\n", + " warnings.warn(\n", + " \"Only {} clusters are available to resample ({} in the smallest group of \"\n", + " \"clusters); even after expansion for the small number of clusters, the \"\n", + " \"confidence interval is unreliable and likely too narrow. At least 6 \"\n", + " \"clusters, and at least 4 in every group of clusters, are \"\n", + " \"recommended.\".format(int(n_total), int(n_smallest))\n", + " )\n", + " return ci_expanded, df\n", + "\n", + " def _interval_level(self):\n", + " '''\n", + " The confidence level at which the bootstrap distribution is read:\n", + " the expanded level when the interval is expanded, otherwise `ci`.\n", + " '''\n", + " return self.__ci_expanded if self.__ci_expanded is not None else self.__ci\n", + "\n", + " def _bca_interval_idx(self, bias, acceleration, ci_expanded):\n", + " '''\n", + " Indexes of the BCa interval limits. When `ci_expanded` is given, the\n", + " interval is read at that expanded level; if the BCa adjustment is\n", + " undefined there, the expanded percentile limits are used instead.\n", + " '''\n", + " from ._stats_tools import confint_2group_diff as ci2g\n", + "\n", + " if ci_expanded is None:\n", + " return ci2g.compute_interval_limits(bias, acceleration, self.__resamples, self.__ci)\n", + "\n", + " low, high = ci2g.expanded_interval_limits(bias, acceleration, self.__resamples, ci_expanded)\n", + " if (isnan(low) or isnan(high)) and np.isfinite(bias):\n", + " warnings.warn(\n", + " \"The bias-corrected and accelerated adjustment is undefined at the \"\n", + " \"expanded confidence level; the expanded percentile interval is \"\n", + " \"reported in its place.\"\n", + " )\n", + " low, high = ci2g.percentile_interval_idx(ci_expanded, self.__resamples)\n", + " return low, high\n", + "\n", + " def _compute_bca_intervals(self, sorted_bootstraps):\n", + " '''\n", + " Function to compute the bca intervals given the sorted bootstraps.\n", + " '''\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", + " bca_idx_low, bca_idx_high = self._bca_interval_idx(\n", " self.__bias_correction,\n", " self.__acceleration_value,\n", - " self.__resamples,\n", - " self.__ci,\n", + " self.__ci_expanded,\n", " )\n", "\n", " self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n", @@ -436,6 +613,8 @@ " self.__is_paired,\n", " self.__permutation_count,\n", " ps_adjust = self.__ps_adjust,\n", + " control_clusters=self.__control_clusters,\n", + " test_clusters=self.__test_clusters,\n", " )\n", "\n", " if self.__is_paired and not self.__is_proportional:\n", @@ -556,20 +735,53 @@ " )\n", " self.__bec_difference = difference\n", "\n", - " jackknives = ci2g.compute_meandiff_jackknife(\n", - " self.__control, self.__control, is_paired, self.__effect_size\n", - " )\n", + " if self.__is_clustered:\n", + " # The two copies of the control group are resampled independently,\n", + " # so the clusters of the second copy are given distinct labels.\n", + " (codes,), n_clusters = ci2g.cluster_codes(self.__control_clusters)\n", + " codes_copy = codes + n_clusters\n", + " jackknives, deleted, jack_codes, n_codes = ci2g.cluster_jackknife_by_cluster(\n", + " self.__control, self.__control, codes, codes_copy, is_paired, self.__effect_size\n", + " )\n", + " bec_components = ci2g.cluster_variance_components(jackknives, deleted, jack_codes, n_codes)\n", + " else:\n", + " jackknives = ci2g.compute_meandiff_jackknife(\n", + " self.__control, self.__control, is_paired, self.__effect_size\n", + " )\n", + " bec_components = None\n", "\n", " acceleration_value = ci2g._calc_accel(jackknives)\n", "\n", - " bootstraps = ci2g.compute_bootstrapped_diff(\n", - " self.__control,\n", - " self.__control,\n", - " is_paired,\n", - " self.__effect_size,\n", - " self.__resamples,\n", - " self.__random_seed,\n", - " )\n", + " # The baseline curve is expanded for small numbers of clusters in the same\n", + " # way as the effect size itself; the warning for too few clusters, if any,\n", + " # has already been given for the effect size.\n", + " bec_ci_expanded = None\n", + " if self.__ci_expanded is not None:\n", + " level, df = ci2g.expanded_ci_level(self.__ci, bec_components)\n", + " if df is not None:\n", + " bec_ci_expanded = level\n", + " self.__bec_ci_expanded = bec_ci_expanded\n", + "\n", + " if self.__is_clustered:\n", + " bootstraps = ci2g.compute_cluster_bootstrapped_diff(\n", + " self.__control,\n", + " self.__control,\n", + " codes,\n", + " codes_copy,\n", + " is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", + " else:\n", + " bootstraps = ci2g.compute_bootstrapped_diff(\n", + " self.__control,\n", + " self.__control,\n", + " is_paired,\n", + " self.__effect_size,\n", + " self.__resamples,\n", + " self.__random_seed,\n", + " )\n", " self.__bootstraps_baseline_ec = bootstraps\n", "\n", " sorted_bootstraps = npsort(self.__bootstraps_baseline_ec)\n", @@ -580,11 +792,10 @@ " )\n", "\n", " # Compute BCa intervals.\n", - " bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n", + " bca_idx_low, bca_idx_high = self._bca_interval_idx(\n", " bias_correction,\n", " acceleration_value,\n", - " self.__resamples,\n", - " self.__ci,\n", + " bec_ci_expanded,\n", " )\n", "\n", " self.__bec_bca_interval_idx = (bca_idx_low, bca_idx_high)\n", @@ -623,13 +834,23 @@ " warnings.warn(err_temp.substitute(lim_type=\"upper\"), stacklevel=0)\n", "\n", " # Compute percentile intervals.\n", - " pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n", - " pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n", + " pct_idx_low, pct_idx_high = ci2g.percentile_interval_idx(\n", + " bec_ci_expanded if bec_ci_expanded is not None else self.__ci, self.__resamples\n", + " )\n", "\n", " self.__bec_pct_interval_idx = (pct_idx_low, pct_idx_high)\n", " self.__bec_pct_low = sorted_bootstraps[pct_idx_low]\n", " self.__bec_pct_high = sorted_bootstraps[pct_idx_high]\n", "\n", + " if bec_ci_expanded is not None:\n", + " (self.__bec_bca_low_unexpanded, self.__bec_bca_high_unexpanded,\n", + " self.__bec_pct_low_unexpanded, self.__bec_pct_high_unexpanded) = ci2g.unexpanded_interval_limits(\n", + " sorted_bootstraps, bias_correction, acceleration_value, self.__ci\n", + " )\n", + " else:\n", + " self.__bec_bca_low_unexpanded = self.__bec_bca_high_unexpanded = None\n", + " self.__bec_pct_low_unexpanded = self.__bec_pct_high_unexpanded = None\n", + "\n", " @property\n", " def difference(self):\n", " \"\"\"\n", @@ -653,6 +874,56 @@ " return self.__is_proportional\n", "\n", " @property\n", + " def is_clustered(self):\n", + " \"\"\"\n", + " Whether whole clusters of observations, rather than individual\n", + " observations, were resampled by the bootstrap and permutation test.\n", + " \"\"\"\n", + " return self.__is_clustered\n", + "\n", + " @property\n", + " def n_clusters(self):\n", + " \"\"\"\n", + " The number of distinct clusters resampled by the cluster bootstrap;\n", + " None if the observations are not clustered.\n", + " \"\"\"\n", + " return self.__n_clusters\n", + "\n", + " @property\n", + " def cluster_ci_expansion(self):\n", + " \"\"\"\n", + " Whether the confidence interval of clustered data is expanded for a\n", + " small number of clusters.\n", + " \"\"\"\n", + " return self.__cluster_ci_expansion\n", + "\n", + " @property\n", + " def ci_expanded(self):\n", + " \"\"\"\n", + " The confidence level, in percent, at which the cluster-bootstrap\n", + " distribution was read so that the reported `ci`% interval allows for a\n", + " small number of clusters (see `dabest.load`'s `cluster_ci_expansion`).\n", + " None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__ci_expanded\n", + "\n", + " @property\n", + " def expansion_df(self):\n", + " \"\"\"\n", + " The degrees of freedom used to expand the confidence interval for a\n", + " small number of clusters; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__expansion_df\n", + "\n", + " @property\n", + " def _expansion_components(self):\n", + " \"\"\"\n", + " The stratum-by-stratum `(variance, n_clusters)` components of the\n", + " cluster jackknife variance; None if the observations are not clustered.\n", + " \"\"\"\n", + " return self.__expansion_components\n", + "\n", + " @property\n", " def ci(self):\n", " \"\"\"\n", " Returns the width of the confidence interval, in percent.\n", @@ -726,6 +997,38 @@ " return self.__pct_high\n", "\n", " @property\n", + " def bca_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa lower\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__bca_low_unexpanded\n", + "\n", + " @property\n", + " def bca_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the BCa upper\n", + " limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__bca_high_unexpanded\n", + "\n", + " @property\n", + " def pct_low_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " lower limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__pct_low_unexpanded\n", + "\n", + " @property\n", + " def pct_high_unexpanded(self):\n", + " \"\"\"\n", + " For an interval expanded for a small number of clusters, the percentile\n", + " upper limit before expansion; None if the interval was not expanded.\n", + " \"\"\"\n", + " return self.__pct_high_unexpanded\n", + "\n", + " @property\n", " def pvalue_brunner_munzel(self):\n", " try:\n", " return self.__pvalue_brunner_munzel\n", @@ -912,6 +1215,38 @@ " The percentile confidence interval lower limit for baseline error.\n", " \"\"\"\n", " return self.__bec_pct_high\n", + "\n", + " @property\n", + " def bec_bca_low_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's BCa lower limit before expansion for a\n", + " small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_bca_low_unexpanded\n", + "\n", + " @property\n", + " def bec_bca_high_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's BCa upper limit before expansion for a\n", + " small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_bca_high_unexpanded\n", + "\n", + " @property\n", + " def bec_pct_low_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's percentile lower limit before expansion for\n", + " a small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_pct_low_unexpanded\n", + "\n", + " @property\n", + " def bec_pct_high_unexpanded(self):\n", + " \"\"\"\n", + " The baseline error curve's percentile upper limit before expansion for\n", + " a small number of clusters; None if it was not expanded.\n", + " \"\"\"\n", + " return self.__bec_pct_high_unexpanded\n", " " ] }, @@ -1050,6 +1385,7 @@ " experiment_label=None,\n", " mini_meta=False,\n", " ps_adjust=False,\n", + " cluster_ci_expansion=True,\n", " ):\n", " \"\"\"\n", " Parses the data from a Dabest object, enabling plotting and printing\n", @@ -1070,6 +1406,9 @@ " self.__delta2 = delta2\n", " self.__is_mini_meta = mini_meta\n", " self.__ps_adjust = ps_adjust\n", + " self.__cluster_ci_expansion = cluster_ci_expansion\n", + " self.__expansion_components = []\n", + " self.__delta2_ci_expanded = None\n", "\n", " def __pre_calc(self):\n", " from .misc_tools import print_greeting, get_varname\n", @@ -1083,10 +1422,21 @@ "\n", " out = []\n", " reprs = []\n", + " self.__expansion_components = []\n", + " self.__delta2_ci_expanded = None\n", "\n", " grouped_data = {name: group[yvar].copy() for name, group in dat.groupby(xvar, observed=False)}\n", + "\n", + " # The cluster label of every observation, for a cluster-aware analysis.\n", + " cluster_col = getattr(self.__dabest_obj, \"cluster_col\", None)\n", + " if cluster_col is not None:\n", + " grouped_clusters = {name: group[cluster_col].to_numpy() for name, group in dat.groupby(xvar, observed=False)}\n", + " else:\n", + " grouped_clusters = {name: None for name in grouped_data}\n", + "\n", " if self.__delta2:\n", " mixed_data = []\n", + " mixed_clusters = []\n", " for j, current_tuple in enumerate(idx):\n", " if self.__is_paired != \"sequential\":\n", " cname = current_tuple[0]\n", @@ -1099,6 +1449,8 @@ " test = grouped_data[tname]\n", " mixed_data.append(control)\n", " mixed_data.append(test)\n", + " mixed_clusters.append(grouped_clusters[cname])\n", + " mixed_clusters.append(grouped_clusters[tname])\n", " bootstraps_delta_delta = ci2g.compute_delta2_bootstrapped_diff(\n", " mixed_data[0],\n", " mixed_data[1],\n", @@ -1108,7 +1460,17 @@ " self.__resamples,\n", " self.__random_seed,\n", " self.__is_proportional,\n", + " clusters=mixed_clusters if cluster_col is not None else None,\n", " )\n", + " if cluster_col is not None and self.__cluster_ci_expansion:\n", + " # Expand the delta-delta interval for a small number of clusters.\n", + " components = ci2g.delta2_cluster_variance_components(\n", + " *[np.asarray(x) for x in mixed_data[:4]],\n", + " *mixed_clusters[:4],\n", + " self.__is_paired,\n", + " )\n", + " level, df = ci2g.expanded_ci_level(self.__ci, components)\n", + " self.__delta2_ci_expanded = level if df is not None else None\n", "\n", " for j, current_tuple in enumerate(idx):\n", " if self.__is_paired != \"sequential\":\n", @@ -1130,8 +1492,12 @@ " self.__resamples,\n", " self.__permutation_count,\n", " self.__random_seed,\n", - " self.__ps_adjust\n", + " self.__ps_adjust,\n", + " control_clusters=grouped_clusters[cname],\n", + " test_clusters=grouped_clusters[tname],\n", + " cluster_ci_expansion=self.__cluster_ci_expansion,\n", " )\n", + " self.__expansion_components.append(result._expansion_components)\n", " r_dict = result.to_dict()\n", " r_dict[\"control\"] = cname\n", " r_dict[\"test\"] = tname\n", @@ -1170,16 +1536,22 @@ " \"test\",\n", " \"control_N\",\n", " \"test_N\",\n", + " \"n_clusters\",\n", " \"effect_size\",\n", " \"is_paired\",\n", " \"difference\",\n", " \"ci\",\n", + " \"ci_expanded\",\n", " \"bca_low\",\n", " \"bca_high\",\n", " \"bca_interval_idx\",\n", " \"pct_low\",\n", " \"pct_high\",\n", " \"pct_interval_idx\",\n", + " \"bca_low_unexpanded\",\n", + " \"bca_high_unexpanded\",\n", + " \"pct_low_unexpanded\",\n", + " \"pct_high_unexpanded\",\n", " \"bootstraps\",\n", " \"resamples\",\n", " \"random_seed\",\n", @@ -1212,6 +1584,10 @@ " \"bec_pct_interval_idx\",\n", " \"bec_pct_low\",\n", " \"bec_pct_high\",\n", + " \"bec_bca_low_unexpanded\",\n", + " \"bec_bca_high_unexpanded\",\n", + " \"bec_pct_low_unexpanded\",\n", + " \"bec_pct_high_unexpanded\",\n", " ]\n", " self.__results = out_.reindex(columns=columns_in_order)\n", " self.__results.dropna(axis=\"columns\", how=\"all\", inplace=True)\n", @@ -1229,7 +1605,8 @@ " )\n", " elif self.__delta2:\n", " self.__delta_delta = DeltaDelta(\n", - " self, self.__permutation_count, bootstraps_delta_delta, self.__ci\n", + " self, self.__permutation_count, bootstraps_delta_delta, self.__ci,\n", + " ci_expanded=self.__delta2_ci_expanded,\n", " )\n", " reprs.append(self.__delta_delta.__repr__(header=False))\n", "\n", @@ -1418,6 +1795,7 @@ "\n", " contrast_marker_kwargs=None, # es_marker_kwargs=None, OLD\n", " contrast_errorbar_kwargs=None, # es_errorbar_kwargs=None, OLD\n", + " contrast_expanded_errorbar_kwargs=None,\n", "\n", " prop_sample_counts=False,\n", " prop_sample_counts_kwargs=None,\n", @@ -1509,6 +1887,13 @@ " observations.\n", " show_sample_size : boolean, default True\n", " Whether or not to display the sample size of each group in the axis label.\n", + " When `cluster_col` was set in `dabest.load()`, the label also reports the\n", + " number of distinct clusters in that group, on its own line, since that is\n", + " the count the cluster-aware bootstrap actually resamples: `(N=,\n", + " n=)` instead of the usual `(N=)`. For vertical\n", + " Cumming plots, including two-column Sankey plots, the gap between the\n", + " raw-data and contrast axes is then sized to the labels, so they clear the\n", + " contrast axes.\n", " show_delta2, show_mini_meta : boolean, default True\n", " If delta-delta or mini-meta delta is calculated, whether or not to\n", " show the delta-delta plot or mini-meta plot.\n", @@ -1647,6 +2032,16 @@ " contrast_errorbar_kwargs: dict, default None\n", " Pass relevant keyword arguments to the effectsize errorbar plotting. If none, the following keywords are passed:\n", " {'color': 'black', 'lw': 2, 'linestyle': '-', 'alpha': 1,'zorder': 1,}\n", + " contrast_expanded_errorbar_kwargs: dict, default None\n", + " When `cluster_col` is set, intervals are expanded for the number of\n", + " clusters (see `dabest.load`'s `cluster_ci_expansion`). The plotted\n", + " bootstrap distribution does not change, so the expanded interval\n", + " reaches further into its tails than its nominal `ci`% interval. To\n", + " show this, the unexpanded interval (the nominal `ci`% interval of\n", + " the plotted distribution) is drawn as the usual errorbar, and the\n", + " expansion beyond it as a thinner line. Pass keyword arguments here\n", + " to style the thinner line; by default it takes the errorbar's\n", + " keywords at 40% of its line width.\n", "\n", " prop_sample_counts: bool, default False\n", " Show the sample counts for each group in proportional plots\n", @@ -1661,10 +2056,22 @@ " {\"linestyle\": \"-\", \"linewidth\": 2, \"zorder\": -2, \"color\": 'dimgray', \"alpha\": 1}\n", " \n", "\t\tshow_baseline_ec : boolean, default False\n", - " Whether or not to display the baseline error curve. The baseline error curve\n", - " represents the distribution of the effect size when comparing the control\n", - " group to itself, providing a reference for the inherent variability or noise\n", - " in the data. When True, this curve is plotted alongside the main effect size\n", + " Whether or not to display the baseline error curve (bec). The bec is the\n", + " bootstrap distribution obtained by comparing the leftmost (\"control\") group\n", + " of each `idx` tuple to a resample of itself, so that its own difference is\n", + " 0 and its spread shows the sampling noise inherent to that group alone. It\n", + " is always computed as an *unpaired* comparison, even when `paired` is set\n", + " for the main analysis, because it stands in for \"no relationship between\n", + " the two sides of the comparison\" rather than for the design actually used.\n", + " For a paired analysis this means the bec is not directly comparable in\n", + " scale to the real (paired) effect-size curves: pairing removes shared\n", + " between-subject variation from the real curves but not from the bec, and\n", + " when `cluster_col` is set this asymmetry is amplified, since the bec then\n", + " resamples whole clusters against an independent resample of themselves,\n", + " while the real paired curves largely cancel the between-cluster variation.\n", + " The bec can be much wider than the real curves in that case, and may need\n", + " its own `contrast_ylim`; see the Plot Aesthetics tutorial for an example.\n", + " When True, this curve is plotted alongside the main effect size\n", " distribution, allowing for a visual comparison of the observed effect against\n", " the baseline variability.\n", "\n", @@ -1744,6 +2151,11 @@ " \"bca_high\",\n", " ]\n", "\n", + " if \"n_clusters\" in results_df.columns:\n", + " default_cols.insert(default_cols.index(\"effect_size\"), \"n_clusters\")\n", + " if \"ci_expanded\" in results_df.columns:\n", + " default_cols.insert(default_cols.index(\"ci\") + 1, \"ci_expanded\")\n", + "\n", " cols_of_interest = default_cols + stats_columns\n", "\n", " return results_df[cols_of_interest]\n", @@ -1753,6 +2165,27 @@ " return self.__for_print\n", "\n", " @property\n", + " def cluster_ci_expansion(self):\n", + " \"\"\"\n", + " Whether confidence intervals of clustered data are expanded for a small\n", + " number of clusters.\n", + " \"\"\"\n", + " return self.__cluster_ci_expansion\n", + "\n", + " @property\n", + " def _expansion_components(self):\n", + " \"\"\"\n", + " For each comparison, in the order of `results`, the stratum-by-stratum\n", + " `(variance, n_clusters)` components of its cluster jackknife variance,\n", + " or None if the observations are not clustered.\n", + " \"\"\"\n", + " try:\n", + " self.__results\n", + " except AttributeError:\n", + " self.__pre_calc()\n", + " return self.__expansion_components\n", + "\n", + " @property\n", " def _plot_data(self):\n", " return self.__dabest_obj._plot_data\n", "\n", @@ -2194,6 +2627,14 @@ "outputs": [], "source": [ "#| export\n", + "def _count_sign_patterns(n):\n", + " \"\"\"The number of ways to swap or not swap each of `n` clusters, as a float.\"\"\"\n", + " try:\n", + " return float(2 ** int(n))\n", + " except OverflowError:\n", + " return float(\"inf\")\n", + "\n", + "\n", "class PermutationTest:\n", " \"\"\"\n", " A class to compute and report permutation tests.\n", @@ -2216,6 +2657,17 @@ " ps_adjust : bool, default False\n", " If True, the p-value is adjusted according to Phipson & Smyth (2010).\n", " # https://doi.org/10.2202/1544-6115.1585\n", + " control_clusters : array-like, default None\n", + " test_clusters : array-like, default None\n", + " The cluster (e.g. participant) that each observation in `control` and\n", + " `test` belongs to. When supplied, labels are reshuffled at the cluster\n", + " level: for paired data, control and test are swapped for whole clusters\n", + " at a time; for unpaired data with clusters nested within groups, whole\n", + " clusters are reassigned between the groups; and for unpaired data with\n", + " clusters spanning both groups, each cluster's control and test\n", + " observations are swapped as whole sets. In every case the observations\n", + " within a cluster are kept together, so that heterogeneity of the effect\n", + " between clusters is reflected in the null distribution.\n", "\n", " \n", " Returns\n", @@ -2236,9 +2688,16 @@ " permutation_count:int=5000, # The number of permutations (reshuffles) to perform.\n", " random_seed:int=12345,#`random_seed` is used to seed the random number generator during bootstrap resampling. This ensures that the generated permutations are replicable.\n", " ps_adjust:bool=False,\n", + " control_clusters=None, # Cluster label of each observation in `control`; see the class docstring.\n", + " test_clusters=None, # Cluster label of each observation in `test`.\n", " **kwargs):\n", " from ._stats_tools.effsize import two_group_difference\n", - " from ._stats_tools.confint_2group_diff import calculate_group_var\n", + " from ._stats_tools.confint_2group_diff import (\n", + " calculate_group_var,\n", + " cluster_codes,\n", + " cluster_tables,\n", + " expand_cluster_draw,\n", + " )\n", " \n", "\n", " self.__permutation_count = permutation_count\n", @@ -2247,6 +2706,12 @@ " if is_paired and len(control) != len(test):\n", " raise ValueError(\"The two arrays do not have the same length.\")\n", "\n", + " is_clustered = control_clusters is not None or test_clusters is not None\n", + " if is_clustered and (control_clusters is None or test_clusters is None):\n", + " err1 = \"Both `control_clusters` and `test_clusters` must be supplied \"\n", + " err2 = \"for a cluster-aware permutation test.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " # Initialise random number generator.\n", " # rng = random.default_rng(seed=random_seed)\n", " rng = RandomState(PCG64(random_seed))\n", @@ -2267,8 +2732,79 @@ " self.__permutations = []\n", " self.__permutations_var = []\n", "\n", - " for i in range(int(self.__permutation_count)):\n", + " # The number of distinct (two-sided) permutations, used by the\n", + " # Phipson & Smyth (2010) adjustment.\n", + " if is_clustered:\n", + " (control_codes, test_codes), n_clusters = cluster_codes(control_clusters, test_clusters)\n", + " if len(control_codes) != CONTROL_LEN or len(test_codes) != TEST_LEN:\n", + " err1 = \"`control_clusters` and `test_clusters` must have the same lengths \"\n", + " err2 = \"as `control` and `test` respectively.\"\n", + " raise ValueError(err1 + err2)\n", + "\n", " if is_paired:\n", + " if not np.array_equal(control_codes, test_codes):\n", + " err1 = \"In a paired analysis every control observation must belong to the \"\n", + " err2 = \"same cluster as the test observation it is paired with.\"\n", + " raise ValueError(err1 + err2)\n", + " # Control and test are swapped for whole clusters at a time; each\n", + " # pattern of swaps and its mirror image give the same |effect size|.\n", + " totalPermutations = _count_sign_patterns(n_clusters) / 2\n", + " else:\n", + " bag_codes = array([*control_codes, *test_codes])\n", + " offsets, members = cluster_tables(bag_codes, n_clusters)\n", + " cluster_sizes = offsets[1:] - offsets[:-1]\n", + " control_per_cluster = np.bincount(control_codes, minlength=n_clusters)\n", + " clusters_shared = bool(\n", + " ((control_per_cluster > 0) & (control_per_cluster < cluster_sizes)).any()\n", + " )\n", + "\n", + " if clusters_shared:\n", + " # Clusters contribute to both groups: a cluster's control and\n", + " # test observations are swapped as whole sets (the analogue of\n", + " # the paired sign flip). Clusters present in one group only\n", + " # are left where they are.\n", + " shared_cluster = (control_per_cluster > 0) & (control_per_cluster < cluster_sizes)\n", + " n_shared = int(shared_cluster.sum())\n", + " is_control = arange(len(BAG)) < CONTROL_LEN\n", + " if n_shared == n_clusters:\n", + " # Swapping every cluster mirrors the effect size exactly.\n", + " totalPermutations = _count_sign_patterns(n_shared) / 2\n", + " else:\n", + " totalPermutations = _count_sign_patterns(n_shared)\n", + " else:\n", + " # Clusters are nested within groups: whole clusters are\n", + " # reassigned between the control and test groups.\n", + " n_control_clusters = int((control_per_cluster > 0).sum())\n", + " if 2 * n_control_clusters == n_clusters:\n", + " totalPermutations = binomcoeff(n_clusters, n_control_clusters) / 2\n", + " else:\n", + " totalPermutations = binomcoeff(n_clusters, n_control_clusters)\n", + " elif CONTROL_LEN == TEST_LEN:\n", + " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN) / 2\n", + " else:\n", + " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)\n", + "\n", + " for i in range(int(self.__permutation_count)):\n", + " if is_clustered and is_paired:\n", + " # Swap control and test for whole clusters at a time.\n", + " flip = rng.randint(0, 2, n_clusters).astype(bool)[control_codes]\n", + " control_sample = np.where(flip, test, control)\n", + " test_sample = np.where(flip, control, test)\n", + "\n", + " elif is_clustered and clusters_shared:\n", + " # Swap the control and test sets of randomly chosen shared clusters.\n", + " swap = rng.randint(0, 2, n_clusters).astype(bool) & shared_cluster\n", + " new_is_control = is_control ^ swap[bag_codes]\n", + " control_sample = BAG[new_is_control]\n", + " test_sample = BAG[~new_is_control]\n", + "\n", + " elif is_clustered:\n", + " # Reassign whole clusters between the control and test groups.\n", + " perm = rng.permutation(n_clusters).astype(np.int64)\n", + " control_sample = BAG[expand_cluster_draw(perm[:n_control_clusters], offsets, members)]\n", + " test_sample = BAG[expand_cluster_draw(perm[n_control_clusters:], offsets, members)]\n", + "\n", + " elif is_paired:\n", " # Select which control-test pairs to swap.\n", " random_idx = rng.choice(CONTROL_LEN,\n", " rng.randint(0, CONTROL_LEN+1),\n", @@ -2292,7 +2828,7 @@ " False, effect_size)\n", " \n", " group_var = calculate_group_var(var(control_sample, ddof=1), \n", - " CONTROL_LEN, \n", + " len(control_sample), \n", " var(test_sample, ddof=1), \n", " len(test_sample))\n", " self.__permutations.append(es)\n", @@ -2309,11 +2845,6 @@ " # https://rdrr.io/cran/statmod/src/R/permp.R\n", " # (assumes two-sided test)\n", "\n", - " if CONTROL_LEN == TEST_LEN:\n", - " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)/2\n", - " else:\n", - " totalPermutations = binomcoeff(CONTROL_LEN + TEST_LEN, TEST_LEN)\n", - "\n", " if totalPermutations <= 10e3:\n", " # use exact calculation\n", " p = arange(1, totalPermutations + 1)/totalPermutations\n", diff --git a/nbs/API/forest_plot.ipynb b/nbs/API/forest_plot.ipynb index 6fd10835..a1933bea 100644 --- a/nbs/API/forest_plot.ipynb +++ b/nbs/API/forest_plot.ipynb @@ -87,7 +87,8 @@ " effect_size: str = \"mean_diff\", \n", " contrast_type: str = None,\n", " ci_type: str = \"bca\",\n", - " idx: Optional[List[int]] = None\n", + " idx: Optional[List[int]] = None,\n", + " include_unexpanded: bool = False,\n", ") -> List:\n", " \"\"\"\n", " Loads plot data based on specified effect size and contrast type.\n", @@ -105,11 +106,17 @@ " idx: Optional[List[int]], default=None\n", " List of indices to select from the contrast objects if delta-delta experiment. \n", " If None, only the delta-delta objects are plotted.\n", + " include_unexpanded: bool, default False\n", + " If True, also return, for each curve, the `(low, high)` limits of its\n", + " interval before expansion for a small number of clusters, or\n", + " `(None, None)` if the interval was not expanded.\n", "\n", " Returns\n", " -------\n", " List: Contrast plot data based on specified parameters.\n", " \"\"\"\n", + " from .plot_tools import unexpanded_limits\n", + "\n", " # Effect size and contrast types\n", " effect_attr = \"hedges_g\" if effect_size == 'delta_g' else effect_size\n", " contrast_attr = {\"delta2\": \"delta_delta\", \"mini_meta\": \"mini_meta\"}.get(contrast_type)\n", @@ -117,6 +124,7 @@ " # Testing\n", " if idx is not None:\n", " bootstraps, differences, bcalows, bcahighs = [], [], [], []\n", + " unexpanded = []\n", " for current_idx, index_group in enumerate(idx):\n", " current_contrast = data[current_idx]\n", " if len(index_group)>0:\n", @@ -148,6 +156,7 @@ " differences.append(current_plot_data.results.difference[index_val])\n", " bcalows.append(current_plot_data.results.get(ci_type+'_low')[index_val])\n", " bcahighs.append(current_plot_data.results.get(ci_type+'_high')[index_val]) \n", + " unexpanded.append(unexpanded_limits(current_plot_data.results, ci_type, index_val))\n", " else:\n", " if contrast_type == 'delta':\n", " contrast_plot_data = [getattr(contrast, effect_attr) for contrast in data]\n", @@ -160,6 +169,8 @@ " differences = [element for innerList in differences_nested for element in innerList]\n", " bcalows = [element for innerList in bcalows_nested for element in innerList]\n", " bcahighs = [element for innerList in bcahighs_nested for element in innerList]\n", + " unexpanded = [unexpanded_limits(result.results, ci_type, i)\n", + " for result in contrast_plot_data for i in range(len(result.results))]\n", "\n", " else: # contrast_type == 'delta2' or 'mini_meta'\n", " contrast_plot_data = [getattr(getattr(contrast, effect_attr), contrast_attr) for contrast in data]\n", @@ -169,7 +180,10 @@ " differences = [result.difference for result in contrast_plot_data]\n", " bcalows = [result.results.get(ci_type+'_low')[0] for result in contrast_plot_data]\n", " bcahighs = [result.results.get(ci_type+'_high')[0] for result in contrast_plot_data]\n", + " unexpanded = [unexpanded_limits(result.results, ci_type, 0) for result in contrast_plot_data]\n", "\n", + " if include_unexpanded:\n", + " return bootstraps, differences, bcalows, bcahighs, unexpanded\n", " return bootstraps, differences, bcalows, bcahighs\n", "\n", "def check_for_errors(**kwargs):\n", @@ -522,6 +536,7 @@ " zeroline_kwargs: Optional[dict] = None,\n", " marker_kwargs: Optional[dict] = None,\n", " errorbar_kwargs: Optional[dict] = None,\n", + " expanded_errorbar_kwargs: Optional[dict] = None,\n", ")-> plt.Figure:\n", " \"\"\" \n", " Custom function that generates a forest plot from given contrast objects, suitable for a range of data analysis types, including those from packages like DABEST-python.\n", @@ -595,25 +610,33 @@ " Additional arguments for the effect size marker customization.\n", " errorbar_kwargs : Optional[dict], default=None\n", " Additional arguments for the effect size error bar customization.\n", + " expanded_errorbar_kwargs : Optional[dict], default=None\n", + " For intervals expanded for a small number of clusters (see\n", + " `dabest.load`'s `cluster_ci_expansion`), the unexpanded interval (the\n", + " nominal interval of the plotted bootstrap distribution) is drawn as the\n", + " usual error bar, and the expansion beyond it as a thinner line. Additional\n", + " arguments here style the thinner line; by default it takes the error\n", + " bar's arguments at 40% of its line width.\n", "\n", " Returns\n", " -------\n", " plt.Figure\n", " The matplotlib figure object with the generated forest plot.\n", " \"\"\"\n", - " from .plot_tools import halfviolin\n", + " from .plot_tools import halfviolin, plot_ci_whisker, expanded_errorbar_kwargs_from\n", "\n", " # Check for errors in the input arguments\n", " all_kwargs = locals()\n", " contrast_type = check_for_errors(**all_kwargs)\n", "\n", " # Load plot data and extract info\n", - " bootstraps, differences, bcalows, bcahighs = load_plot_data(\n", + " bootstraps, differences, bcalows, bcahighs, unexpanded = load_plot_data(\n", " data = data, \n", " effect_size = effect_size, \n", " contrast_type = contrast_type,\n", " ci_type = ci_type,\n", - " idx = idx\n", + " idx = idx,\n", + " include_unexpanded = True,\n", " )\n", " # Adjust figure size based on orientation\n", " number_of_curves_to_plot = len(bootstraps)\n", @@ -650,13 +673,14 @@ " )\n", " \n", " ## Plotting the effect sizes and confidence intervals\n", + " expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs, expanded_errorbar_kwargs)\n", " for k in range(1, number_of_curves_to_plot + 1):\n", " if horizontal:\n", " ax.plot(differences[k - 1], k, **marker_kwargs) \n", - " ax.plot([bcalows[k - 1], bcahighs[k - 1]], [k, k], **errorbar_kwargs) \n", " else:\n", " ax.plot(k, differences[k - 1], **marker_kwargs)\n", - " ax.plot([k, k], [bcalows[k - 1], bcahighs[k - 1]], **errorbar_kwargs)\n", + " plot_ci_whisker(ax, k, bcalows[k - 1], bcahighs[k - 1], horizontal, errorbar_kwargs,\n", + " unexpanded[k - 1][0], unexpanded[k - 1][1], expanded_errorbar_kwargs)\n", " \n", " # Aesthetic Adjustments\n", " ## Handle the custom color palette\n", diff --git a/nbs/API/load.ipynb b/nbs/API/load.ipynb index 86c7782c..8f1a9631 100644 --- a/nbs/API/load.ipynb +++ b/nbs/API/load.ipynb @@ -72,6 +72,8 @@ " x1_level=None,\n", " mini_meta=False,\n", " ps_adjust=False,\n", + " cluster_col=None,\n", + " cluster_ci_expansion=True,\n", "):\n", " \"\"\"\n", " Loads data in preparation for estimation statistics.\n", @@ -135,6 +137,57 @@ " ps_adjust : boolean, default False\n", " Indicator of whether to adjust calculated p-value according to Phipson & Smyth (2010)\n", " # https://doi.org/10.2202/1544-6115.1585\n", + " cluster_col : string, default None\n", + " Name of the column identifying the independent sampling unit (cluster)\n", + " that each observation belongs to, for example a participant who\n", + " contributes several observations, or several pairs of paired\n", + " observations. When supplied, the bootstrap resamples whole clusters\n", + " with replacement (a cluster bootstrap) and the permutation test\n", + " reshuffles labels at the cluster level (swapping the control and test\n", + " observations of whole clusters, or reassigning whole clusters between\n", + " groups when clusters are nested within groups), so that the confidence\n", + " intervals and permutation p-values account for the correlation between\n", + " observations from the same cluster. This works with both unpaired data\n", + " and paired data (`paired` with `id_col`): for paired data, `id_col`\n", + " identifies the pairs and `cluster_col` the units the pairs are nested\n", + " in, and every pair must belong to a single cluster. The parametric and\n", + " rank-based tests reported in `statistical_tests` do not account for\n", + " clustering. Note that the baseline error curve shown by\n", + " `.plot(show_baseline_ec=True)` is always an unpaired comparison (see\n", + " that argument's docstring), so with `cluster_col` set it can become\n", + " much wider than a paired analysis's real effect-size curves.\n", + " cluster_ci_expansion : boolean, default True\n", + " Only used when `cluster_col` is set. Bootstrap confidence intervals are\n", + " too narrow when there are few independent units: with around 15 to 30\n", + " clusters, a nominal 95% cluster-bootstrap interval typically covers the\n", + " true effect only 90 to 94% of the time. When True, the percentile and\n", + " bias-corrected and accelerated intervals (including those of the\n", + " baseline error curve, delta-delta and mini-meta analyses) are therefore\n", + " expanded for the number of clusters with the expanded percentile\n", + " method of Hesterberg (2015, The American Statistician, 69(4),\n", + " 371-386): each interval is read further into the tails of the same\n", + " bootstrap distribution, at a level derived from a t distribution with\n", + " degrees of freedom based on the number of clusters. When clusters are\n", + " nested within groups, or some clusters appear in only some groups, the\n", + " groups of clusters are resampled independently, and their degrees of\n", + " freedom are combined with the Welch-Satterthwaite approximation. The\n", + " reported confidence level (`ci`) is unchanged; the level actually read\n", + " is reported as `ci_expanded` in the results, alongside the unexpanded\n", + " limits (`bca_low_unexpanded` and so on). Plots draw the unexpanded\n", + " interval (the nominal `ci`% interval of the plotted bootstrap\n", + " distribution) as the usual thick bar, and the expansion beyond it as a\n", + " thinner line (see `contrast_expanded_errorbar_kwargs` in `plot()`). The\n", + " correction fades as the number of clusters grows. In simulations the\n", + " expanded intervals came within about 3 percentage points of nominal\n", + " coverage for every effect size once there were at least 6 clusters in\n", + " all and at least 4 in each independently resampled group of clusters\n", + " (for example 6 participants who each take part in every condition, or\n", + " 8 participants split between two conditions); with fewer, no bootstrap\n", + " interval is reliable, and a warning is given. Because expanded\n", + " intervals are read further into the\n", + " tails of the bootstrap distribution, consider increasing `resamples`\n", + " (to 20000, say) when there are few clusters. Set to False to report\n", + " unexpanded cluster-bootstrap intervals.\n", "\n", " Returns\n", " -------\n", @@ -159,6 +212,8 @@ " x1_level,\n", " mini_meta,\n", " ps_adjust,\n", + " cluster_col=cluster_col,\n", + " cluster_ci_expansion=cluster_ci_expansion,\n", " )" ] }, diff --git a/nbs/API/misc_tools.ipynb b/nbs/API/misc_tools.ipynb index 3e28644e..99ce36bf 100644 --- a/nbs/API/misc_tools.ipynb +++ b/nbs/API/misc_tools.ipynb @@ -751,20 +751,52 @@ " return (color_col, bootstraps_color_by_group, n_groups, filled, raw_colors,\n", " plot_palette_raw, plot_palette_contrast, plot_palette_sankey)\n", "\n", + "def _tick_label_gap_inches(n_lines: int, fontsize) -> float:\n", + " \"\"\"\n", + " Vertical gap, in inches, that keeps `n_lines` of tick labels at `fontsize`\n", + " on the upper (raw data) axes clear of the lower (contrast) axes: the text,\n", + " plus room for the tick marks and a small margin.\n", + " \"\"\"\n", + " from matplotlib.font_manager import FontProperties\n", + "\n", + " size_pt = FontProperties(size=fontsize).get_size_in_points()\n", + " return (n_lines * 1.2 * size_pt + 14) / 72\n", + "\n", + "\n", + "def _hspace_for_tick_labels(\n", + " n_lines: int,\n", + " fontsize,\n", + " available_height: float,\n", + " minimum: float,\n", + " ) -> float:\n", + " \"\"\"\n", + " Vertical gap, as a fraction of each axes' height, that keeps multi-line\n", + " tick labels on the upper (raw data) axes clear of the lower (contrast) axes.\n", + "\n", + " `available_height` is the height in inches shared by both axes and the gap\n", + " between them (see `_tick_label_gap_inches`). Never returns less than `minimum`.\n", + " \"\"\"\n", + " needed = _tick_label_gap_inches(n_lines, fontsize)\n", + " # Axes heights h and gap g satisfy 2h + g = available_height and g = hspace * h.\n", + " remaining = max(available_height - needed, 0.25 * available_height)\n", + " return max(minimum, 2 * needed / remaining)\n", + "\n", + "\n", "def initialize_fig(\n", - " plot_kwargs: dict, \n", - " dabest_obj: object, \n", - " show_delta2: bool, \n", - " show_mini_meta: bool, \n", - " is_paired: bool, \n", - " show_pairs: bool, \n", + " plot_kwargs: dict,\n", + " dabest_obj: object,\n", + " show_delta2: bool,\n", + " show_mini_meta: bool,\n", + " is_paired: bool,\n", + " show_pairs: bool,\n", " proportional: bool,\n", " float_contrast: bool,\n", - " effect_size_type: str, \n", - " yvar: str, \n", - " horizontal: bool, \n", + " effect_size_type: str,\n", + " yvar: str,\n", + " horizontal: bool,\n", " show_table: bool,\n", " color_col: str,\n", + " two_col_sankey: bool = False,\n", " ):\n", " \"\"\"\n", " Initialize the figure and axes for the plotter function.\n", @@ -797,6 +829,9 @@ " A boolean flag to determine if the table will be shown in horizontal plot.\n", " color_col : str\n", " The column name for coloring the data points.\n", + " two_col_sankey : bool, default False\n", + " Whether the plot is a two-column (non-flow) Sankey diagram, whose raw\n", + " data tick labels span several lines.\n", " \"\"\"\n", " # Params\n", " fig_size = plot_kwargs[\"fig_size\"]\n", @@ -837,6 +872,18 @@ " width_ratios_ga = [2.5, 1]\n", " h_space_cummings = (0.1 if plot_kwargs[\"gridkey\"] is not None\n", " else 0.3)\n", + " # Cluster-aware sample-size labels add a line to each raw-data tick label\n", + " # (see `add_counts_to_ticks`), on top of the two lines of an ordinary label\n", + " # or the four of a two-column Sankey label. In that case the gap between the\n", + " # raw data and contrast axes is sized to the labels, so they clear the\n", + " # contrast axes below.\n", + " size_gap_to_labels = (\n", + " plot_kwargs[\"gridkey\"] is None\n", + " and plot_kwargs[\"show_sample_size\"]\n", + " and getattr(dabest_obj, \"cluster_col\", None) is not None\n", + " )\n", + " n_label_lines = (4 if two_col_sankey else 2) + 1\n", + " fontsize_rawxlabel = plot_kwargs.get(\"fontsize_rawxlabel\")\n", "\n", " if plot_kwargs[\"ax\"] is not None:\n", " # New in v0.2.6.\n", @@ -886,6 +933,30 @@ " )\n", "\n", " contrast_axes = axins\n", + " elif size_gap_to_labels:\n", + " # The contrast axes hangs a fixed distance below the raw data\n", + " # axes, sized to the tick labels, rather than a fraction of the\n", + " # axes' height: a layout engine that later resizes the raw data\n", + " # axes (e.g. with `figure.autolayout`) would otherwise stretch\n", + " # the gap along with it.\n", + " fig_height = fig.get_figheight()\n", + " available = (ax_position.y1 - ax_position.y0) * fig_height # inches\n", + " gap = max(min(_tick_label_gap_inches(n_label_lines, fontsize_rawxlabel), 0.75 * available),\n", + " h_space_cummings * available / (2 + h_space_cummings))\n", + " plot_height = (available - gap) / 2\n", + " axins = rawdata_axes.inset_axes(\n", + " [0, -1, 1, 1],\n", + " transform=rawdata_axes.transAxes\n", + " + matplotlib.transforms.ScaledTranslation(0, -gap, fig.dpi_scale_trans),\n", + " )\n", + " rawdata_axes.set_position(\n", + " [\n", + " ax_position.x0,\n", + " ax_position.y0 + (plot_height + gap) / fig_height,\n", + " (ax_position.x1 - ax_position.x0),\n", + " plot_height / fig_height,\n", + " ]\n", + " )\n", " else:\n", " axins = rawdata_axes.inset_axes([0, -1 - h_space_cummings, 1, 1])\n", " plot_height = (ax_position.y1 - ax_position.y0) / (2 + h_space_cummings)\n", @@ -922,6 +993,15 @@ " **init_fig_kwargs\n", " )\n", " else:\n", + " if size_gap_to_labels:\n", + " subplot_height = (plt.rcParams[\"figure.subplot.top\"]\n", + " - plt.rcParams[\"figure.subplot.bottom\"])\n", + " h_space_cummings = _hspace_for_tick_labels(\n", + " n_label_lines,\n", + " fontsize_rawxlabel,\n", + " fig_size[1] * subplot_height,\n", + " h_space_cummings,\n", + " )\n", " fig, axx = plt.subplots(\n", " nrows=2, gridspec_kw={\"hspace\": h_space_cummings}, **init_fig_kwargs\n", " )\n", @@ -1078,13 +1158,14 @@ "\n", "\n", "def add_counts_to_ticks(\n", - " plot_data: pd.DataFrame, \n", - " xvar: str, \n", - " yvar: str, \n", - " rawdata_axes: axes.Axes, \n", - " plot_kwargs: dict, \n", - " flow: bool, \n", - " horizontal: bool\n", + " plot_data: pd.DataFrame,\n", + " xvar: str,\n", + " yvar: str,\n", + " rawdata_axes: axes.Axes,\n", + " plot_kwargs: dict,\n", + " flow: bool,\n", + " horizontal: bool,\n", + " cluster_col: str = None\n", " ):\n", " \"\"\"\n", "\n", @@ -1106,24 +1187,33 @@ " Whether sankey flow is enabled or not.\n", " horizontal : bool\n", " A boolean flag to determine if the plot is for horizontal plotting.\n", + " cluster_col : str, default None\n", + " Name of the column identifying the cluster (e.g. participant) each\n", + " observation belongs to, as declared to `dabest.load()`. When supplied,\n", + " each group's label also reports the number of distinct clusters\n", + " contributing to that group, on its own line below the observation\n", + " count, since that is the count the cluster-aware bootstrap actually\n", + " resamples.\n", " \"\"\"\n", "\n", " # Add the counts to the rawdata axes xticks.\n", " counts = plot_data.groupby(xvar, observed=False).count()[yvar]\n", - " \n", - " def lookup_value(text):\n", + " if cluster_col is not None:\n", + " cluster_counts = plot_data.groupby(xvar, observed=False)[cluster_col].nunique()\n", + "\n", + " def lookup_value(series, text):\n", " try:\n", - " return str(counts.loc[text])\n", + " return str(series.loc[text])\n", " except KeyError:\n", " try:\n", " numeric_key = pd.to_numeric(text, errors='coerce')\n", " if pd.notnull(numeric_key):\n", - " return str(counts.loc[numeric_key])\n", + " return str(series.loc[numeric_key])\n", " except (ValueError, KeyError):\n", " pass\n", " print(f\"Key '{text}' not found in counts.\")\n", " return \"N/A\"\n", - " \n", + "\n", " ticks_with_counts = []\n", " if horizontal:\n", " get_label, get_ticks = rawdata_axes.get_yticklabels, rawdata_axes.get_yticks\n", @@ -1131,7 +1221,7 @@ " else:\n", " get_label, get_ticks = rawdata_axes.get_xticklabels, rawdata_axes.get_xticks\n", " set_label, set_major_loc_method = rawdata_axes.set_xticklabels, rawdata_axes.xaxis.set_major_locator\n", - " \n", + "\n", " for ticklab in get_label():\n", " t = ticklab.get_text()\n", "\n", @@ -1140,11 +1230,17 @@ " else:\n", " te = t.split('\\n')[-1] # Get the last line of the label\n", "\n", - " value = lookup_value(te)\n", + " value = lookup_value(counts, te)\n", + " if cluster_col is not None:\n", + " n_clusters = lookup_value(cluster_counts, te)\n", + " count_text = \"(N={},\\n n={})\".format(value, n_clusters)\n", + " else:\n", + " count_text = \"(N={})\".format(value)\n", + "\n", " if horizontal:\n", - " ticks_with_counts.append(f\"{t} (N={value})\")\n", + " ticks_with_counts.append(f\"{t} {count_text}\")\n", " else:\n", - " ticks_with_counts.append(f\"{t}\\n(N={value})\")\n", + " ticks_with_counts.append(f\"{t}\\n{count_text}\")\n", "\n", " set_major_loc_method(plt.FixedLocator(get_ticks()))\n", "\n", diff --git a/nbs/API/plot_tools.ipynb b/nbs/API/plot_tools.ipynb index 3e876553..533613c0 100644 --- a/nbs/API/plot_tools.ipynb +++ b/nbs/API/plot_tools.ipynb @@ -1297,8 +1297,9 @@ " plot_kwargs: dict, \n", " horizontal: bool, \n", " show_pairs: bool,\n", - " contrast_marker_kwargs: dict, \n", + " contrast_marker_kwargs: dict,\n", " contrast_errorbar_kwargs: dict,\n", + " contrast_expanded_errorbar_kwargs: dict = None,\n", " ):\n", " \"\"\"\n", " Add mini meta-analysis or delta-delta violin plots to the contrast plot.\n", @@ -1331,6 +1332,9 @@ " Keyword arguments for the effectsize marker.\n", " contrast_errorbar_kwargs: dict\n", " Keyword arguments for the effectsize errorbar.\n", + " contrast_expanded_errorbar_kwargs : dict, default None\n", + " Keyword arguments for the thin line showing how far the interval was\n", + " expanded for a small number of clusters (see `plot_ci_whisker`).\n", " \"\"\"\n", "\n", " # Plot the curve\n", @@ -1353,12 +1357,10 @@ " position = max(rawdata_axes.get_yticks()) + 1\n", " half = \"bottom\"\n", " effsize_x, effsize_y = difference, [position]\n", - " ci_x, ci_y = [ci_low, ci_high], [position, position]\n", " else:\n", " position = max(rawdata_axes.get_xticks()) + 1\n", " half = \"right\"\n", " effsize_x, effsize_y = [position], difference\n", - " ci_x, ci_y = [position, position], [ci_low, ci_high]\n", "\n", " v = contrast_axes.violinplot(\n", " data[~np.isinf(data)], positions=[position], **contrast_kwargs\n", @@ -1373,11 +1375,9 @@ " **contrast_marker_kwargs\n", " )\n", " # Plot the confidence interval.\n", - " contrast_axes.plot(\n", - " ci_x,\n", - " ci_y,\n", - " **contrast_errorbar_kwargs\n", - " )\n", + " unexpanded_low, unexpanded_high = unexpanded_limits(dabest_obj.results, ci_type, 0)\n", + " plot_ci_whisker(contrast_axes, position, ci_low, ci_high, horizontal, contrast_errorbar_kwargs,\n", + " unexpanded_low, unexpanded_high, contrast_expanded_errorbar_kwargs)\n", "\n", " # Add labels and ticks\n", " if horizontal:\n", @@ -1422,23 +1422,109 @@ " return delta2_axes, contrast_xtick_labels\n", "\n", "\n", + "def unexpanded_limits(results: pd.DataFrame, prefix: str, index: int):\n", + " \"\"\"\n", + " The unexpanded interval limits stored in `results` for row `index`, e.g.\n", + " `bca_low_unexpanded` and `bca_high_unexpanded` for `prefix=\"bca\"`, or\n", + " `(None, None)` if the interval was not expanded for a small number of clusters.\n", + " \"\"\"\n", + " low = results.get(prefix + \"_low_unexpanded\")\n", + " high = results.get(prefix + \"_high_unexpanded\")\n", + " if low is None or high is None:\n", + " return None, None\n", + " low, high = low[index], high[index]\n", + " if pd.isna(low) or pd.isna(high):\n", + " return None, None\n", + " return low, high\n", + "\n", + "\n", + "def plot_ci_whisker(\n", + " ax: axes.Axes,\n", + " position: float,\n", + " ci_low: float,\n", + " ci_high: float,\n", + " horizontal: bool,\n", + " errorbar_kwargs: dict,\n", + " unexpanded_low: float = None,\n", + " unexpanded_high: float = None,\n", + " expanded_errorbar_kwargs: dict = None,\n", + " ):\n", + " \"\"\"\n", + " Draw a confidence interval at `position` on `ax`.\n", + "\n", + " When the interval has been expanded for a small number of clusters, the\n", + " unexpanded limits are given too. The unexpanded interval, which the plotted\n", + " bootstrap distribution itself spans, is then drawn as the usual thick bar,\n", + " and the expansion beyond it as a thinner line (styled by\n", + " `expanded_errorbar_kwargs`), so that the plot shows which part of the\n", + " interval comes from resampling and which is the small-sample allowance.\n", + "\n", + " Parameters\n", + " ----------\n", + " ax : axes.Axes\n", + " Matplotlib axis object to plot on.\n", + " position : float\n", + " The tick at which to draw the interval.\n", + " ci_low, ci_high : float\n", + " The limits of the reported interval.\n", + " horizontal : bool\n", + " If the plot is horizontal.\n", + " errorbar_kwargs : dict\n", + " Keyword arguments for the interval line.\n", + " unexpanded_low, unexpanded_high : float, default None\n", + " The limits before expansion, if the interval was expanded.\n", + " expanded_errorbar_kwargs : dict, default None\n", + " Keyword arguments for the thinner line showing the expansion.\n", + " \"\"\"\n", + " def segment(low, high, kwargs):\n", + " if horizontal:\n", + " ax.plot([low, high], [position, position], **kwargs)\n", + " else:\n", + " ax.plot([position, position], [low, high], **kwargs)\n", + "\n", + " if unexpanded_low is None or unexpanded_high is None:\n", + " segment(ci_low, ci_high, errorbar_kwargs)\n", + " return\n", + " if expanded_errorbar_kwargs is None:\n", + " expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(errorbar_kwargs)\n", + " segment(ci_low, ci_high, expanded_errorbar_kwargs)\n", + " segment(unexpanded_low, unexpanded_high, errorbar_kwargs)\n", + "\n", + "\n", + "def expanded_errorbar_kwargs_from(errorbar_kwargs: dict, custom_kwargs: dict = None) -> dict:\n", + " \"\"\"\n", + " Keyword arguments for the thin line that shows the expansion of an\n", + " interval for a small number of clusters: those of the interval line, at\n", + " 40% of its width (at least 0.75 points), updated with `custom_kwargs`.\n", + " \"\"\"\n", + " kwargs = dict(errorbar_kwargs)\n", + " width = kwargs.pop(\"linewidth\", kwargs.pop(\"lw\", 2))\n", + " kwargs[\"lw\"] = max(0.75, 0.4 * width)\n", + " if custom_kwargs:\n", + " if \"linewidth\" in custom_kwargs:\n", + " kwargs.pop(\"lw\")\n", + " kwargs.update(custom_kwargs)\n", + " return kwargs\n", + "\n", + "\n", "def effect_size_curve_plotter(\n", - " ticks_to_plot: list, \n", - " ticks_for_baseline_ec: list, \n", - " results: pd.DataFrame, \n", - " ci_type: str, \n", - " contrast_axes: axes.Axes, \n", - " contrast_kwargs: dict, \n", - " bootstraps_color_by_group: bool, \n", + " ticks_to_plot: list,\n", + " ticks_for_baseline_ec: list,\n", + " results: pd.DataFrame,\n", + " ci_type: str,\n", + " contrast_axes: axes.Axes,\n", + " contrast_kwargs: dict,\n", + " bootstraps_color_by_group: bool,\n", " plot_palette_contrast: dict,\n", - " horizontal: bool, \n", - " contrast_marker_kwargs: dict, \n", + " horizontal: bool,\n", + " contrast_marker_kwargs: dict,\n", " contrast_errorbar_kwargs: dict,\n", - " idx: list, \n", - " is_paired: bool, \n", - " contrast_paired_lines: bool, \n", + " idx: list,\n", + " is_paired: bool,\n", + " contrast_paired_lines: bool,\n", " contrast_paired_lines_kwargs: dict,\n", - " show_baseline_ec: bool = False\n", + " show_baseline_ec: bool = False,\n", + " contrast_expanded_errorbar_kwargs: dict = None,\n", " ):\n", " \"\"\"\n", " Add effect size curves to the contrast plot.\n", @@ -1477,9 +1563,13 @@ " Keyword arguments for the repeated measures lines.\n", " show_baseline_ec : bool\n", " Whether to show the baseline effect curve.\n", + " contrast_expanded_errorbar_kwargs : dict, default None\n", + " Keyword arguments for the thin line showing how far an interval was\n", + " expanded for a small number of clusters (see `plot_ci_whisker`).\n", " \"\"\"\n", "\n", - " def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high):\n", + " def plot_effect_size(tick, group, control, bootstrap, effsize, ci_low, ci_high,\n", + " unexpanded=(None, None)):\n", " # Create the violinplot\n", " if horizontal: \n", " contrast_kwargs.update({'orientation': 'horizontal', 'widths': 1})\n", @@ -1496,13 +1586,9 @@ " halfviolin(v, fill_color=fc, alpha=contrast_alpha, half=half)\n", "\n", " # Plot the confidence interval\n", - " if horizontal:\n", - " ci_x, ci_y = [ci_low, ci_high], [tick, tick]\n", - " else:\n", - " ci_x, ci_y = [tick, tick], [ci_low, ci_high]\n", - " \n", - " contrast_axes.plot(ci_x, ci_y, **contrast_errorbar_kwargs)\n", - " \n", + " plot_ci_whisker(contrast_axes, tick, ci_low, ci_high, horizontal, contrast_errorbar_kwargs,\n", + " unexpanded[0], unexpanded[1], contrast_expanded_errorbar_kwargs)\n", + "\n", " return \"{}\\nminus\\n{}\".format(group, control)\n", " \n", " if contrast_kwargs.get('alpha') is not None:\n", @@ -1531,7 +1617,8 @@ " )\n", "\n", " label = plot_effect_size(tick, current_group, current_control, current_bootstrap,\n", - " current_effsize, current_ci_low, current_ci_high)\n", + " current_effsize, current_ci_low, current_ci_high,\n", + " unexpanded_limits(results, ci_type, int(j)))\n", " contrast_xtick_labels.append(label)\n", "\n", " # Add baseline effect curve plotting\n", @@ -1553,8 +1640,9 @@ " contrast_axes.plot(effsize_x, effsize_y, **contrast_marker_kwargs)\n", " \n", " if show_baseline_ec:\n", - " _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap, \n", - " bec_effsize, bec_ci_low, bec_ci_high)\n", + " _ = plot_effect_size(tick, bec_group, bec_control, bec_bootstrap,\n", + " bec_effsize, bec_ci_low, bec_ci_high,\n", + " unexpanded_limits(bec_results, 'bec_' + ci_type, j))\n", " # Baseline Curve doesn't need tick text\n", "\n", " # Add lines for repeated measures data\n", diff --git a/nbs/API/plotter.ipynb b/nbs/API/plotter.ipynb index 9d4a0986..b16c44c6 100644 --- a/nbs/API/plotter.ipynb +++ b/nbs/API/plotter.ipynb @@ -132,6 +132,7 @@ " gridkey_delimiters=[';', '>', '_'],\n", " gridkey_kwargs=None,\n", " contrast_marker_kwargs=None, contrast_errorbar_kwargs=None,\n", + " contrast_expanded_errorbar_kwargs=None,\n", " prop_sample_counts=False, prop_sample_counts_kwargs=None, \n", " contrast_paired_lines=True, contrast_paired_lines\n", "\t\tshow_baseline_ec=False,\n", @@ -167,7 +168,8 @@ " barplotter,\n", " table_for_horizontal_plots,\n", " add_counts_to_prop_plots,\n", - " add_bars_to_plot\n", + " add_bars_to_plot,\n", + " expanded_errorbar_kwargs_from,\n", " )\n", "\n", " warnings.filterwarnings(\n", @@ -235,7 +237,8 @@ " yvar = yvar,\n", " horizontal = horizontal,\n", " show_table = table_kwargs['show'],\n", - " color_col = color_col\n", + " color_col = color_col,\n", + " two_col_sankey = two_col_sankey,\n", " )\n", " \n", " # Plotting the rawdata.\n", @@ -369,13 +372,14 @@ " # Add the counts to the rawdata axes xticks.\n", " if show_sample_size:\n", " add_counts_to_ticks(\n", - " plot_data = plot_data, \n", - " xvar = xvar, \n", - " yvar = yvar, \n", - " rawdata_axes = rawdata_axes, \n", + " plot_data = plot_data,\n", + " xvar = xvar,\n", + " yvar = yvar,\n", + " rawdata_axes = rawdata_axes,\n", " plot_kwargs = plot_kwargs,\n", " flow = sankey_kwargs[\"flow\"],\n", " horizontal = horizontal,\n", + " cluster_col = dabest_obj.cluster_col,\n", " )\n", "\n", " # Add counts to prop plots (embedded in the plot bars)\n", @@ -433,6 +437,11 @@ " ticks_to_plot = [x+0.25 for x in ticks_to_plot]\n", "\n", " ## Plot the bootstraps, then the effect sizes and CIs.\n", + " # Intervals expanded for a small number of clusters are drawn as a thick bar\n", + " # over the unexpanded interval and a thinner line over the expansion.\n", + " contrast_expanded_errorbar_kwargs = expanded_errorbar_kwargs_from(\n", + " contrast_errorbar_kwargs, plot_kwargs.get(\"contrast_expanded_errorbar_kwargs\")\n", + " )\n", " contrast_paired_lines = False if float_contrast or not sankey_kwargs[\"flow\"] else plot_kwargs[\"contrast_paired_lines\"]\n", " (current_group, current_control,\n", " current_effsize, contrast_xtick_labels) = effect_size_curve_plotter(\n", @@ -452,6 +461,7 @@ " contrast_paired_lines = contrast_paired_lines,\n", "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tcontrast_paired_lines_kwargs = contrast_paired_lines_kwargs,\n", "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tshow_baseline_ec = show_baseline_ec,\n", + " contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs,\n", " )\n", "\n", " ## Plot mini-meta or delta-delta violin\n", @@ -471,6 +481,7 @@ " show_pairs = show_pairs,\n", " contrast_marker_kwargs = contrast_marker_kwargs,\n", " contrast_errorbar_kwargs = contrast_errorbar_kwargs,\n", + " contrast_expanded_errorbar_kwargs = contrast_expanded_errorbar_kwargs,\n", " )\n", " ## Contrast bars\n", " contrast_bars = plot_kwargs[\"contrast_bars\"]\n", diff --git a/nbs/API/precompile.ipynb b/nbs/API/precompile.ipynb index 95b8c834..e6e4dcc9 100644 --- a/nbs/API/precompile.ipynb +++ b/nbs/API/precompile.ipynb @@ -99,7 +99,12 @@ " (confint_2group_diff.delta2_bootstrap_loop, \n", " (dummy_control, dummy_test, dummy_control, dummy_test, 10, 1.0, 12345, False)),\n", " (confint_2group_diff._compute_quantile, (0.5, 0.1, 0.1)),\n", - " (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3))\n", + " (confint_2group_diff.calculate_group_var, (1.0, 3, 1.0, 3)),\n", + " (confint_2group_diff.cluster_bootstrap_draws,\n", + " (np.array([0, 1, 2], dtype=np.int64), np.array([0, 3], dtype=np.int64), 10, 12345)),\n", + " (confint_2group_diff.expand_cluster_draw,\n", + " (np.array([0, 1], dtype=np.int64), np.array([0, 1, 3], dtype=np.int64),\n", + " np.array([0, 1, 2], dtype=np.int64))),\n", " ]\n", " \n", " for func, args in tqdm(funcs, desc=\"Compiling numba functions\"):\n", diff --git a/nbs/tests/test_cluster_bootstrap.py b/nbs/tests/test_cluster_bootstrap.py new file mode 100644 index 00000000..f03168d8 --- /dev/null +++ b/nbs/tests/test_cluster_bootstrap.py @@ -0,0 +1,916 @@ +"""Tests for the cluster-aware bootstrap and permutation test (`cluster_col`).""" + +import numpy as np +import pandas as pd +import pytest + +from dabest._api import load +from dabest._effsize_objects import TwoGroupsEffectSize, PermutationTest +from dabest._stats_tools import confint_2group_diff as ci2g + + +def make_clustered_data(n_participants=12, n_sets=4, sd_participant=1.5, seed=3): + """ + Within-subject design in long format: every participant contributes + `n_sets` paired sets of observations across three levels, so that the + pairs (identified by `pair`) are nested within participants (`ID`). + """ + rng = np.random.default_rng(seed) + levels = ["L1", "L2", "L3"] + rows = [] + for p in range(n_participants): + u_p = rng.normal(0, sd_participant) # participant-specific sensitivity + for s in range(n_sets): + u_s = rng.normal(0, 0.5) + for k, level in enumerate(levels): + rows.append( + dict( + ID="P{:02d}".format(p), + pair=p * n_sets + s, + Level=level, + Y=3 + 0.4 * k * (1 + u_p) + u_s + rng.normal(0, 0.5), + ) + ) + return pd.DataFrame(rows).sort_values(["pair", "Level"]).reset_index(drop=True) + + +DF = make_clustered_data() +PAIRED_KWARGS = dict( + idx=("L1", "L2", "L3"), + x="Level", + y="Y", + paired="sequential", + id_col="pair", + resamples=500, + random_seed=11, +) + + +@pytest.fixture(scope="module") +def naive(): + return load(DF, **PAIRED_KWARGS) + + +@pytest.fixture(scope="module") +def clustered(): + return load(DF, cluster_col="ID", **PAIRED_KWARGS) + + +# --------------------------------------------------------------------------- +# Low-level resampling machinery +# --------------------------------------------------------------------------- +def test_cluster_codes_pool_labels_across_groups(): + (c0, c1), n = ci2g.cluster_codes(["a", "b", "a"], ["b", "c"]) + assert n == 3 + assert c0.tolist() == [0, 1, 0] + assert c1.tolist() == [1, 2] + + with pytest.raises(ValueError): + ci2g.cluster_codes(["a", None, "b"]) + + +def test_cluster_tables_and_expand_cluster_draw(): + codes = np.array([2, 0, 2, 1, 0]) + offsets, members = ci2g.cluster_tables(codes, 3) + assert offsets.tolist() == [0, 2, 3, 5] + assert members[offsets[0] : offsets[1]].tolist() == [1, 4] + assert members[offsets[2] : offsets[3]].tolist() == [0, 2] + + draw = np.array([2, 2, 1], dtype=np.int64) + idx = ci2g.expand_cluster_draw(draw, offsets, members) + assert idx.tolist() == [0, 2, 0, 2, 3] + + +def test_cluster_strata_follow_the_design(): + # Fully within-cluster: every cluster in both groups -> one stratum. + strata, offsets = ci2g.cluster_strata(([0, 1, 2], [0, 1, 2]), 3) + assert offsets.tolist() == [0, 3] + + # Nested: clusters 0-1 only in control, 2-3 only in test -> one stratum per group. + strata, offsets = ci2g.cluster_strata(([0, 1], [2, 3]), 4) + assert offsets.tolist() == [0, 2, 4] + assert sorted(strata[:2].tolist()) == [0, 1] + assert sorted(strata[2:].tolist()) == [2, 3] + + # Mixed: one stratum per membership pattern. + strata, offsets = ci2g.cluster_strata(([0, 1, 2], [1, 2, 3]), 4) + assert offsets.tolist() == [0, 1, 2, 4] + + +def test_cluster_bootstrap_reduces_to_ordinary_bootstrap_for_singleton_clusters(): + rng = np.random.default_rng(1) + x0 = rng.normal(0, 1, 15) + x1 = rng.normal(0.5, 1, 15) + ids = np.arange(15) + + # Paired: every pair is its own cluster. + plain = ci2g.compute_bootstrapped_diff(x0, x1, "baseline", "mean_diff", 300, 7) + clus = ci2g.compute_cluster_bootstrapped_diff(x0, x1, ids, ids, "baseline", "mean_diff", 300, 7) + assert np.array_equal(plain, clus) + + # Unpaired: every observation is its own cluster (nested design). + x1u = rng.normal(0.5, 1, 20) + plain = ci2g.compute_bootstrapped_diff(x0, x1u, None, "mean_diff", 300, 7) + clus = ci2g.compute_cluster_bootstrapped_diff( + x0, x1u, np.arange(15), 100 + np.arange(20), None, "mean_diff", 300, 7 + ) + assert np.array_equal(plain, clus) + + # The delete-one jackknife also coincides. + plain = ci2g.compute_meandiff_jackknife(x0, x1, "baseline", "mean_diff") + clus = ci2g.compute_cluster_jackknife(x0, x1, ids, ids, "baseline", "mean_diff") + assert plain == pytest.approx(clus) + + +def test_cluster_bootstrap_keeps_pairs_together(): + # With a constant within-pair difference in every cluster, every paired + # cluster-bootstrap resample must reproduce that difference exactly. + x0 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) + x1 = x0 + np.array([0.5, 0.5, 1.0, 1.0, 2.0, 2.0]) + clusters = np.array([0, 0, 1, 1, 2, 2]) + boots = ci2g.compute_cluster_bootstrapped_diff(x0, x1, clusters, clusters, "baseline", "mean_diff", 200, 3) + # Three equally sized clusters are drawn with replacement, so every + # resample's mean difference is the mean of three cluster differences. + from itertools import combinations_with_replacement + + allowed = {round(np.mean(c), 10) for c in combinations_with_replacement([0.5, 1.0, 2.0], 3)} + assert set(np.round(boots, 10)).issubset(allowed) + + +def test_cluster_bootstrap_rejects_misaligned_paired_clusters(): + x = np.arange(6, dtype=float) + with pytest.raises(ValueError, match="same cluster"): + ci2g.compute_cluster_bootstrapped_diff(x, x, [0, 0, 1, 1, 2, 2], [0, 1, 1, 2, 2, 0], "baseline", "mean_diff", 10, 1) + + +# --------------------------------------------------------------------------- +# dabest.load with cluster_col +# --------------------------------------------------------------------------- +def test_point_estimates_are_unchanged_by_clustering(naive, clustered): + for effect_size in ["mean_diff", "cohens_d", "hedges_g"]: + n = getattr(naive, effect_size).results["difference"].to_numpy() + c = getattr(clustered, effect_size).results["difference"].to_numpy() + assert n == pytest.approx(c) + + +def test_cluster_intervals_are_wider_under_participant_effects(naive, clustered): + rn = naive.mean_diff.results + rc = clustered.mean_diff.results + sd_ratio = [np.std(c) / np.std(n) for c, n in zip(rc["bootstraps"], rn["bootstraps"])] + assert all(r > 1.2 for r in sd_ratio) + assert ((rc["bca_high"] - rc["bca_low"]) > (rn["bca_high"] - rn["bca_low"])).all() + + +def test_results_report_clusters(naive, clustered): + rc = clustered.mean_diff.results + assert rc["n_clusters"].tolist() == [12, 12] + assert "n_clusters" not in naive.mean_diff.results.columns + + assert clustered.cluster_col == "ID" + assert naive.cluster_col is None + assert "clusters" in repr(clustered) + assert "cluster" in repr(clustered.mean_diff) + assert "cluster" not in repr(naive.mean_diff) + + +def test_baseline_pairing_with_clusters(): + result = load(DF, cluster_col="ID", **dict(PAIRED_KWARGS, paired="baseline")).mean_diff.results + assert result["n_clusters"].tolist() == [12, 12] + assert result["control"].tolist() == ["L1", "L1"] + + +def test_unpaired_with_clusters_spanning_both_groups(): + kwargs = dict(idx=("L1", "L3"), x="Level", y="Y", resamples=300, random_seed=5) + naive = load(DF, **kwargs).mean_diff.results + clustered = load(DF, cluster_col="ID", **kwargs).mean_diff.results + assert clustered["n_clusters"].iloc[0] == 12 + assert clustered["difference"].iloc[0] == pytest.approx(naive["difference"].iloc[0]) + assert 0 <= clustered["pvalue_permutation"].iloc[0] <= 1 + assert len(clustered["permutations"].iloc[0]) == 5000 + + +def test_unpaired_with_clusters_nested_within_groups(): + # Participants P00-P05 measured at L1 only; P06-P11 at L3 only. + df = DF[DF["Level"].isin(["L1", "L3"])] + first_half = df["ID"] < "P06" + df = df[(first_half & (df["Level"] == "L1")) | (~first_half & (df["Level"] == "L3"))] + result = load( + df, idx=("L1", "L3"), x="Level", y="Y", cluster_col="ID", resamples=300, ps_adjust=True + ).mean_diff.results + assert result["n_clusters"].iloc[0] == 12 + assert result["control_N"].iloc[0] == 24 + assert 0 <= result["pvalue_permutation"].iloc[0] <= 1 + + +def test_wide_format_with_clusters(): + wide = DF.pivot(index="pair", columns="Level", values="Y").reset_index() + wide["ID"] = wide["pair"] // 4 + result = load( + wide, idx=("L1", "L2", "L3"), paired="sequential", id_col="pair", cluster_col="ID", resamples=300 + ).mean_diff.results + long_result = load(DF, cluster_col="ID", **dict(PAIRED_KWARGS, resamples=300)).mean_diff.results + assert result["n_clusters"].tolist() == [12, 12] + assert result["difference"].to_numpy() == pytest.approx(long_result["difference"].to_numpy()) + + +def test_delta2_and_mini_meta_with_clusters(): + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + + delta2 = load( + df, x=["Level", "Env"], y="Y", delta2=True, experiment="Env", + paired="sequential", id_col="pair", cluster_col="ID", resamples=300, + ) + dd = delta2.mean_diff.delta_delta + assert dd.bca_low < dd.difference < dd.bca_high + assert len(dd.bootstraps_delta_delta) == 300 + dg = delta2.hedges_g.delta_delta + assert dg.bca_low < dg.difference < dg.bca_high + + mini_meta = load( + df, idx=(("L1", "L3"),), x="Level", y="Y", mini_meta=True, + paired="sequential", id_col="pair", cluster_col="ID", resamples=300, + ) + mm = mini_meta.mean_diff.mini_meta + assert mm.bca_low < mm.difference < mm.bca_high + + +def test_other_effect_sizes_and_plot_with_clusters(clustered): + import matplotlib + + matplotlib.use("Agg") + assert len(clustered.median_diff.results) == 2 + fig = clustered.mean_diff.plot() + assert fig is not None + + +def test_plot_tick_labels_report_cluster_count(naive, clustered): + import matplotlib + + matplotlib.use("Agg") + + naive_labels = [t.get_text() for t in naive.mean_diff.plot().axes[0].get_xticklabels()] + for label in naive_labels: + assert "n=" not in label + assert "(N=" in label + + clustered_labels = [t.get_text() for t in clustered.mean_diff.plot().axes[0].get_xticklabels()] + for label in clustered_labels: + assert "(N=48,\n n=12)" in label # 12 participants x 4 sets each = 48 observations per level + + # A design where each participant contributes several sets: the cluster + # count in the label must be lower than the observation count. + df = make_clustered_data(n_participants=6, n_sets=5) + clustered_multi = load( + df, idx=("L1", "L2", "L3"), x="Level", y="Y", paired="sequential", + id_col="pair", cluster_col="ID", resamples=200, random_seed=1, + ) + labels = [t.get_text() for t in clustered_multi.mean_diff.plot().axes[0].get_xticklabels()] + for label in labels: + assert "(N=30,\n n=6)" in label + + # Horizontal orientation keeps the group label and N on one line, but still + # breaks N and n onto separate lines. + horiz_labels = [t.get_text() for t in clustered.mean_diff.plot(horizontal=True).axes[0].get_yticklabels()] + for label in horiz_labels: + assert " (N=48,\n n=12)" in label + + +def test_cumming_layout_makes_room_for_cluster_label(naive, clustered): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + + def gap(fig): + raw, contrast = fig.axes[0].get_position(), fig.axes[1].get_position() + return raw.y0 - contrast.y1 + + # Figures created by dabest. + naive_gap = gap(naive.mean_diff.plot(float_contrast=False)) + clustered_gap = gap(clustered.mean_diff.plot(float_contrast=False)) + assert clustered_gap > naive_gap + + # Figures drawn into a user-supplied axes (the contrast axes is an inset, + # placed when the figure is drawn). + def inset_gap(dabest_obj): + f, ax = plt.subplots() + dabest_obj.mean_diff.plot(ax=ax, float_contrast=False) + f.canvas.draw() + renderer = f.canvas.get_renderer() + return ax.get_window_extent(renderer).y0 - ax.contrast_axes.get_window_extent(renderer).y1 + + assert inset_gap(clustered) > inset_gap(naive) + + # Without sample-size labels there is nothing extra to make room for. + assert gap(clustered.mean_diff.plot(float_contrast=False, show_sample_size=False)) == pytest.approx(naive_gap) + plt.close("all") + + +def _label_clearance(raw_ax, contrast_ax): + """Pixels between the lowest raw-data tick label and the top of the contrast axes.""" + fig = raw_ax.figure + fig.canvas.draw() + renderer = fig.canvas.get_renderer() + labels = [t for t in raw_ax.get_xticklabels() if t.get_text()] + label_bottom = min(t.get_window_extent(renderer).y0 for t in labels) + return label_bottom - contrast_ax.get_window_extent(renderer).y1 + + +def test_cluster_labels_clear_the_contrast_axes(): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + rng = np.random.default_rng(0) + df = DF.copy() + df["Yes"] = (rng.random(len(df)) < 0.4).astype(int) + proportional_kwargs = dict(idx=("L1", "L2", "L3"), x="Level", y="Yes", proportional=True, + paired="sequential", id_col="pair", cluster_col="ID", resamples=200) + + cases = [ + (load(DF, cluster_col="ID", **PAIRED_KWARGS), dict(fig_size=(5, 4))), + (load(DF, cluster_col="ID", **PAIRED_KWARGS), dict(fontsize_rawxlabel=16)), + # Two-column Sankey labels span four lines before the cluster count is added. + (load(df, **proportional_kwargs), dict(sankey_kwargs={"flow": False})), + (load(df, **proportional_kwargs), dict(sankey_kwargs={"flow": False}, fig_size=(5, 4))), + ] + for dabest_obj, plot_kwargs in cases: + fig = dabest_obj.mean_diff.plot(**plot_kwargs) + assert _label_clearance(fig.axes[0], fig.axes[1]) > 0, plot_kwargs + + user_kwargs = {k: v for k, v in plot_kwargs.items() if k != "fig_size"} + f, ax = plt.subplots(figsize=(5.5, 5)) + dabest_obj.mean_diff.plot(ax=ax, **user_kwargs) + assert _label_clearance(ax, ax.contrast_axes) > 0, user_kwargs + plt.close("all") + + +def test_gap_for_cluster_labels_survives_autolayout(naive, clustered): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + + def gap_points(dabest_obj): + """Points between the raw data axes and the contrast axes, and below the tick labels.""" + f, ax = plt.subplots(figsize=(6.5, 3.5)) + dabest_obj.mean_diff.plot(ax=ax, float_contrast=False) + clearance = _label_clearance(ax, ax.contrast_axes) + renderer = f.canvas.get_renderer() + gap = ax.get_window_extent(renderer).y0 - ax.contrast_axes.get_window_extent(renderer).y1 + plt.close("all") + return gap * 72 / f.dpi, clearance * 72 / f.dpi + + # `figure.autolayout` resizes the user's axes after dabest has laid it out; + # the gap for the cluster labels must not be stretched along with it. + plain_gap, plain_clearance = gap_points(clustered) + with matplotlib.rc_context({"figure.autolayout": True}): + auto_gap, auto_clearance = gap_points(clustered) + naive_gap, _ = gap_points(naive) + assert auto_gap == pytest.approx(plain_gap, abs=1) + assert 0 < auto_clearance < 20 and 0 < plain_clearance < 20 + assert auto_gap < 1.5 * naive_gap + + +# --------------------------------------------------------------------------- +# Validation +# --------------------------------------------------------------------------- +def test_cluster_col_validation(): + with pytest.raises(IndexError, match="not a column"): + load(DF, cluster_col="missing", **PAIRED_KWARGS) + + with pytest.raises(ValueError, match="same column as `y`"): + load(DF, cluster_col="Y", **PAIRED_KWARGS) + + bad = DF.copy() + bad.loc[0, "ID"] = "P99" # one row of pair 0 now belongs to another participant + with pytest.raises(ValueError, match="single cluster"): + load(bad, cluster_col="ID", **PAIRED_KWARGS) + + bad = DF.copy() + bad.loc[0, "ID"] = None + with pytest.raises(ValueError, match="missing values"): + load(bad, cluster_col="ID", **PAIRED_KWARGS) + + wide = DF.pivot(index="pair", columns="Level", values="Y").reset_index() + with pytest.raises(ValueError, match="one of the groups"): + load(wide, idx=("L1", "L2"), paired="sequential", id_col="pair", cluster_col="L1") + + +def test_two_groups_effect_size_direct_api(): + rng = np.random.default_rng(2) + control = rng.normal(0, 1, 8) + test = rng.normal(0.5, 1, 8) + clusters = np.repeat([0, 1, 2, 3], 2) + + result = TwoGroupsEffectSize( + control, test, "mean_diff", is_paired="baseline", resamples=200, + control_clusters=clusters, test_clusters=clusters, + ) + assert result.is_clustered + assert result.n_clusters == 4 + assert result.to_dict()["n_clusters"] == 4 + + plain = TwoGroupsEffectSize(control, test, "mean_diff", is_paired="baseline", resamples=200) + assert not plain.is_clustered + assert plain.n_clusters is None + + with pytest.raises(ValueError, match="same lengths"): + TwoGroupsEffectSize(control, test, "mean_diff", resamples=200, control_clusters=clusters[:4], test_clusters=clusters) + + with pytest.raises(ValueError, match="Both"): + TwoGroupsEffectSize(control, test, "mean_diff", resamples=200, control_clusters=clusters) + + with pytest.raises(ValueError, match="same cluster"): + TwoGroupsEffectSize( + control, test, "mean_diff", is_paired="baseline", resamples=200, + control_clusters=clusters, test_clusters=clusters[::-1], + ) + + +def test_cluster_permutation_test(): + rng = np.random.default_rng(4) + control = rng.normal(0, 1, 12) + test = control + 1.0 + clusters = np.repeat([0, 1, 2, 3], 3) + + # Paired: with a constant difference of 1 in every pair, each cluster-level + # sign flip changes the mean difference by a multiple of 2 * 3 / 12. + paired = PermutationTest( + control, test, "mean_diff", is_paired="baseline", permutation_count=200, + control_clusters=clusters, test_clusters=clusters, + ) + assert 0 <= paired.pvalue <= 1 + assert set(np.round(paired.permutations, 10)).issubset({-1.0, -0.5, 0.0, 0.5, 1.0}) + + # Unpaired with shared clusters, adjusted p-value. + shared = PermutationTest( + control, test, "mean_diff", permutation_count=200, ps_adjust=True, + control_clusters=clusters, test_clusters=clusters, + ) + assert 0 <= shared.pvalue <= 1 + assert len(shared.permutations_var) == 200 + + # Shared clusters are permuted by swapping each cluster's control and test + # sets as a whole. When the two sets of every cluster hold the same values, + # no swap can change the effect size, whereas reshuffling observations + # within clusters would. + values = np.array([1.0, 5.0, 2.0, 8.0, 3.0, 9.0]) + sets = np.repeat([0, 1, 2], 2) + identical = PermutationTest( + values, values, "mean_diff", permutation_count=100, + control_clusters=sets, test_clusters=sets, + ) + assert np.allclose(identical.permutations, 0.0) + + # When every cluster's sets differ by a constant, the permutation effect + # sizes can only take the values produced by whole-set swaps. + shifted = PermutationTest( + values, values + 2.0, "mean_diff", permutation_count=100, + control_clusters=sets, test_clusters=sets, + ) + allowed = {-2.0, -2 / 3, 2 / 3, 2.0} + assert all(any(np.isclose(v, a) for a in allowed) for v in shifted.permutations) + + # Unpaired with nested clusters, adjusted p-value. + nested = PermutationTest( + control, test, "mean_diff", permutation_count=200, ps_adjust=True, + control_clusters=clusters, test_clusters=clusters + 10, + ) + assert 0 <= nested.pvalue <= 1 + + +# --------------------------------------------------------------------------- +# Small-sample expansion of cluster-bootstrap intervals (`cluster_ci_expansion`) +# --------------------------------------------------------------------------- +def _hesterberg_level(n, ci=95, df=None): + """ + Hesterberg's (2015) expanded percentile level for a single sample of n units; + `df` replaces the n - 1 degrees of freedom of the t quantile. + """ + from scipy import stats + + alpha = (100 - ci) / 100 + z = np.sqrt(n / (n - 1)) * stats.t.ppf(1 - alpha / 2, n - 1 if df is None else df) + return 100 * (1 - 2 * stats.norm.sf(z)) + + +def test_expanded_level_matches_hesterberg_for_one_stratum(): + for n in (3, 5, 8, 15, 30, 200): + level, df = ci2g.expanded_ci_level(95, [(0.37, n)]) + assert level == pytest.approx(_hesterberg_level(n)) + assert df == pytest.approx(n - 1) + # Any confidence level, and the result does not depend on the variance scale. + assert ci2g.expanded_ci_level(90, [(5.0, 12)])[0] == pytest.approx(_hesterberg_level(12, ci=90)) + assert ci2g.expanded_ci_level(95, [(1e-9, 12)])[0] == pytest.approx(_hesterberg_level(12)) + + +def test_expanded_level_behaviour(): + levels = [ci2g.expanded_ci_level(95, [(1.0, n)])[0] for n in (4, 8, 16, 32, 64, 1000)] + assert all(a > b for a, b in zip(levels, levels[1:])) # fewer clusters, more expansion + assert levels[-1] > 95 and levels[-1] == pytest.approx(95, abs=0.05) + + # Two equal, independently resampled strata: the Welch-Satterthwaite degrees + # of freedom pool both strata, so the expansion is smaller than for either alone. + level, df = ci2g.expanded_ci_level(95, [(1.0, 8), (1.0, 8)]) + assert df == pytest.approx(14) + assert level == pytest.approx(_hesterberg_level(8, df=14)) + assert 95 < level < _hesterberg_level(8) + + # Unequal strata: the degrees of freedom are weighted by the variance shares. + _, df = ci2g.expanded_ci_level(95, [(1.0, 5), (3.0, 20)]) + assert df == pytest.approx(4 ** 2 / (1 / 4 + 3 ** 2 / 19)) + # A stratum carrying a negligible share of the variance barely counts ... + level_dominated, df = ci2g.expanded_ci_level(95, [(1.0, 40), (1e-9, 3)]) + assert df == pytest.approx(39) + assert level_dominated == pytest.approx(_hesterberg_level(40), rel=1e-4) + # ... and a small stratum carrying most of it sets both corrections. + level_dominated, df = ci2g.expanded_ci_level(95, [(1e-9, 40), (1.0, 6)]) + assert df == pytest.approx(5) + assert level_dominated == pytest.approx(_hesterberg_level(6), rel=1e-4) + # Many equal strata. + level, df = ci2g.expanded_ci_level(95, [(1.0, 10)] * 12) + assert df == pytest.approx(12 * 9) and level == pytest.approx(_hesterberg_level(10, df=108)) + + # Whatever the variances, the degrees of freedom lie between those of the + # smallest stratum and the pooled total. + rng = np.random.default_rng(3) + for _ in range(50): + sizes = rng.integers(2, 30, size=rng.integers(2, 5)) + components = list(zip(rng.exponential(1, sizes.size), sizes)) + _, df = ci2g.expanded_ci_level(95, components) + assert sizes.min() - 1 - 1e-9 <= df <= np.sum(sizes - 1) + 1e-9 + + # Strata of a single cluster carry no information and are ignored. + assert ci2g.expanded_ci_level(95, [(1.0, 1), (1.0, 10)])[0] == pytest.approx(_hesterberg_level(10)) + assert ci2g.expanded_ci_level(95, [(1.0, 1)]) == (95, None) + assert ci2g.expanded_ci_level(95, []) == (95, None) + + # No usable variance information: strata are weighted equally. + assert ci2g.expanded_ci_level(95, [(0.0, 8), (0.0, 6)])[1] == pytest.approx(4 / (1 / 7 + 1 / 5)) + + # The smallest group of clusters that carries a real share of the variance, + # used to warn about designs with too few clusters. + assert ci2g.smallest_cluster_group([(1.0, 5), (3.0, 20)]) == 5 + assert ci2g.smallest_cluster_group([(1.0, 40), (1e-9, 3)]) == 40 + assert ci2g.smallest_cluster_group([(1.0, 10)] * 12) == 10 + assert ci2g.smallest_cluster_group([(1.0, 1)]) is None + + # Extreme expansion is floored so that quantile functions stay finite. + level, _ = ci2g.expanded_ci_level(95, [(1.0, 2)]) + assert 100 - level == pytest.approx(100 * ci2g._MIN_EXPANDED_ALPHA) + + +def test_cluster_variance_components_follow_the_strata(): + x = np.arange(12, dtype=float) + y = x + np.linspace(0, 1, 12) + + # Paired: one stratum holding every cluster. + clusters = np.repeat(np.arange(4), 3) + values, deleted, codes, n = ci2g.cluster_jackknife_by_cluster(x, y, clusters, clusters, "baseline", "mean_diff") + components = ci2g.cluster_variance_components(values, deleted, codes, n) + assert [n_s for _, n_s in components] == [4] + assert components[0][0] > 0 + + # Nested: one stratum per group. + values, deleted, codes, n = ci2g.cluster_jackknife_by_cluster( + x[:6], y[6:], np.repeat([0, 1, 2], 2), np.repeat([5, 6, 7], 2), None, "mean_diff") + assert sorted(n_s for _, n_s in ci2g.cluster_variance_components(values, deleted, codes, n)) == [3, 3] + + # Mixed: clusters in both groups, and single-group clusters; a stratum of one + # cluster is left out. + c0 = np.array([0, 0, 1, 1, 2, 2, 3]) + c1 = np.array([0, 0, 1, 1, 2, 2, 4, 4]) + values, deleted, codes, n = ci2g.cluster_jackknife_by_cluster(x[:7], y[:8], c0, c1, None, "mean_diff") + assert sorted(n_s for _, n_s in ci2g.cluster_variance_components(values, deleted, codes, n)) == [3] + + # The delta-delta counterpart. + comps = ci2g.delta2_cluster_variance_components(x, y, x + 1, y + 2, clusters, clusters, clusters, clusters, "baseline") + assert [n_s for _, n_s in comps] == [4] + + +def test_interval_index_helpers(): + assert ci2g.percentile_interval_idx(95, 1000) == (25, 975) + assert ci2g.percentile_interval_idx(99.9999999999, 10) == (0, 9) + + # BCa at an expanded level: valid indexes, within the array. + low, high = ci2g.expanded_interval_limits(0.05, 0.02, 1000, 98.0) + assert 0 <= low < high <= 999 + # Undefined when a large acceleration meets an extreme level. + low, high = ci2g.expanded_interval_limits(0.0, 0.5, 1000, 99.99) + assert np.isnan(low) and np.isnan(high) + low, high = ci2g.expanded_interval_limits(np.inf, 0.0, 1000, 98.0) + assert np.isnan(low) and np.isnan(high) + + +def test_expansion_is_on_by_default_and_can_be_turned_off(clustered): + expanded = clustered.mean_diff.results + unexpanded = load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff.results + + # 12 participants, all present in every group: a single stratum. + assert expanded["ci_expanded"].to_numpy() == pytest.approx(_hesterberg_level(12)) + assert (expanded["ci"] == 95).all() + assert "ci_expanded" not in unexpanded.columns + + # Same point estimates and bootstrap distributions; only where they are read changes. + assert expanded["difference"].to_numpy() == pytest.approx(unexpanded["difference"].to_numpy()) + for boot_on, boot_off in zip(expanded["bootstraps"], unexpanded["bootstraps"]): + assert np.array_equal(boot_on, boot_off) + + for kind in ("bca", "pct", "bec_bca", "bec_pct"): + width_on = expanded[f"{kind}_high"] - expanded[f"{kind}_low"] + width_off = unexpanded[f"{kind}_high"] - unexpanded[f"{kind}_low"] + assert (width_on > width_off).all(), kind + + # The percentile limits are the bootstrap quantiles at the reported levels. + resamples = PAIRED_KWARGS["resamples"] + for row_on, row_off in zip(expanded.itertuples(), unexpanded.itertuples()): + on, off = np.sort(row_on.bootstraps), np.sort(row_off.bootstraps) + a = (100 - row_on.ci_expanded) / 200 + assert row_on.pct_low == on[int(a * resamples)] + assert row_on.pct_high == on[int((1 - a) * resamples)] + assert row_off.pct_low == off[int(0.025 * resamples)] + assert row_off.pct_high == off[int(0.975 * resamples)] + + assert "ci_expanded" in clustered.mean_diff.statistical_tests.columns + assert "read at the" in repr(clustered.mean_diff) + assert "cluster_ci_expansion=False" in repr(clustered) + unexpanded_repr = repr(load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff) + assert "read at the" not in unexpanded_repr + + +def test_unclustered_results_are_unaffected(naive): + results = naive.mean_diff.results + assert "ci_expanded" not in results.columns + resamples = PAIRED_KWARGS["resamples"] + for row in results.itertuples(): + boot = np.sort(row.bootstraps) + assert row.pct_low == boot[int(0.025 * resamples)] + assert row.pct_high == boot[int(0.975 * resamples)] + # The switch only concerns clustered data. + with_switch = load(DF, cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff.results + assert with_switch["bca_low"].to_numpy() == pytest.approx(results["bca_low"].to_numpy()) + assert "Confidence intervals will be expanded" not in repr(naive) + + +def test_expansion_for_unpaired_nested_and_mixed_designs(): + kwargs = dict(x="Level", y="Y", resamples=500, random_seed=4) + # Nested: participants P00-P05 at L1 only, P06-P11 at L3 only (two strata of 6). + df = DF[DF["Level"].isin(["L1", "L3"])] + first_half = df["ID"] < "P06" + nested = df[(first_half & (df["Level"] == "L1")) | (~first_half & (df["Level"] == "L3"))] + result = load(nested, idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] + # Two strata of 6: the narrowness correction of 6 clusters, with between 5 and + # 10 degrees of freedom depending on how the variance divides between them. + assert _hesterberg_level(6, df=10) < result["ci_expanded"] < _hesterberg_level(6) + + # Mixed: a participant measured only in the test group adds a stratum of one, + # which cannot be resampled and so does not change the expansion. + extra = pd.DataFrame({"ID": ["P99"] * 4, "pair": range(900, 904), "Level": "L3", "Y": [5.0, 6.0, 7.0, 5.5]}) + shared = DF[DF["Level"].isin(["L1", "L3"])] + base = load(shared, idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] + mixed = load(pd.concat([shared, extra]), idx=("L1", "L3"), cluster_col="ID", **kwargs).mean_diff.results.iloc[0] + assert mixed["ci_expanded"] == pytest.approx(base["ci_expanded"]) + + +def test_expansion_for_delta2_and_mini_meta(): + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + delta2_kwargs = dict(x=["Level", "Env"], y="Y", delta2=True, experiment="Env", + paired="sequential", id_col="pair", cluster_col="ID", resamples=500) + mini_meta_kwargs = dict(idx=(("L1", "L3"),), x="Level", y="Y", mini_meta=True, + paired="sequential", id_col="pair", cluster_col="ID", resamples=500) + + for effect_size in ("mean_diff", "hedges_g"): + on = getattr(load(df, **delta2_kwargs), effect_size).delta_delta + off = getattr(load(df, cluster_ci_expansion=False, **delta2_kwargs), effect_size).delta_delta + # Every participant contributes to all four groups: a single stratum of 12. + assert on.ci_expanded == pytest.approx(_hesterberg_level(12)) + assert off.ci_expanded is None + assert (on.bca_high - on.bca_low) > (off.bca_high - off.bca_low) + assert (on.pct_high - on.pct_low) > (off.pct_high - off.pct_low) + assert "ci_expanded" in on.results.columns and "ci_expanded" not in off.results.columns + assert "read at the" in repr(on) + + on = load(df, **mini_meta_kwargs).mean_diff.mini_meta + off = load(df, cluster_ci_expansion=False, **mini_meta_kwargs).mean_diff.mini_meta + assert on.ci_expanded > 95 and off.ci_expanded is None + assert (on.bca_high - on.bca_low) > (off.bca_high - off.bca_low) + assert (on.pct_high - on.pct_low) > (off.pct_high - off.pct_low) + assert "ci_expanded" in on.results.columns and "ci_expanded" not in off.results.columns + assert "read at the" in repr(on) and "read at the" not in repr(off) + + +def test_expansion_edge_cases(): + import warnings + + rng = np.random.default_rng(7) + # Two or three clusters: extreme but valid limits, and no index errors. + for n_clusters in (2, 3): + clusters = np.repeat(np.arange(n_clusters), 4) + control = rng.normal(0, 1, clusters.size) + test = control + 0.5 + rng.normal(0, 1, clusters.size) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + result = TwoGroupsEffectSize(control, test, "mean_diff", is_paired="baseline", resamples=300, + permutation_count=10, control_clusters=clusters, test_clusters=clusters) + assert result.ci_expanded > 99 + assert result.bca_low <= result.difference <= result.bca_high + assert result.pct_low <= result.pct_high + + # Too few clusters to resample: the user is warned the interval is unreliable, + # whether there are too few clusters overall ... + clusters = np.repeat(np.arange(5), 4) + control = rng.normal(0, 1, clusters.size) + with pytest.warns(UserWarning, match="Only 5 clusters"): + TwoGroupsEffectSize(control, control + 0.5 + rng.normal(0, 1, clusters.size), "mean_diff", + is_paired="baseline", resamples=300, permutation_count=10, + control_clusters=clusters, test_clusters=clusters) + # ... or too few in one of the independently resampled groups of clusters. + control, test = rng.normal(0, 1, 12), rng.normal(1, 1, 24) + with pytest.warns(UserWarning, match=r"Only 9 clusters .*\(3 in the smallest"): + TwoGroupsEffectSize(control, test, "mean_diff", resamples=300, permutation_count=10, + control_clusters=np.repeat(np.arange(3), 4), + test_clusters=np.repeat(np.arange(10, 16), 4)) + # Enough clusters: no such warning. + clusters = np.repeat(np.arange(6), 4) + control = rng.normal(0, 1, clusters.size) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + TwoGroupsEffectSize(control, control + 0.5 + rng.normal(0, 1, clusters.size), "mean_diff", + is_paired="baseline", resamples=1000, permutation_count=10, + control_clusters=clusters, test_clusters=clusters) + assert not any("available to resample" in str(w.message) for w in caught) + + # One cluster per group: nothing can be expanded, and the user is told so. + control, test = rng.normal(0, 1, 5), rng.normal(1, 1, 5) + with pytest.warns(UserWarning, match="too few clusters"): + result = TwoGroupsEffectSize(control, test, "mean_diff", resamples=200, permutation_count=10, + control_clusters=np.zeros(5), test_clusters=np.ones(5)) + assert result.ci_expanded is None + + # Opt-out on the direct API, and argument validation. + clusters = np.repeat(np.arange(6), 2) + control = rng.normal(0, 1, 12) + result = TwoGroupsEffectSize(control, control + 1, "mean_diff", is_paired="baseline", resamples=200, + permutation_count=10, control_clusters=clusters, test_clusters=clusters, + cluster_ci_expansion=False) + assert result.ci_expanded is None and result.expansion_df is None + with pytest.raises(TypeError, match="cluster_ci_expansion"): + TwoGroupsEffectSize(control, control + 1, "mean_diff", resamples=200, control_clusters=clusters, + test_clusters=clusters, cluster_ci_expansion="yes") + with pytest.raises(TypeError, match="cluster_ci_expansion"): + load(DF, cluster_col="ID", cluster_ci_expansion=1, **PAIRED_KWARGS) + with pytest.raises(ValueError, match="same column as `x`"): + load(DF, cluster_col="Level", **PAIRED_KWARGS) + + +def test_expansion_for_every_effect_size_and_plot(clustered): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + for effect_size in ("mean_diff", "median_diff", "cohens_d", "hedges_g"): + results = getattr(clustered, effect_size).results + assert (results["ci_expanded"] > 95).all(), effect_size + assert (results["bca_low"] <= results["difference"]).all() + assert (results["difference"] <= results["bca_high"]).all() + + unpaired = load(DF, idx=("L1", "L3"), x="Level", y="Y", cluster_col="ID", resamples=300) + assert unpaired.cliffs_delta.results["ci_expanded"].iloc[0] > 95 + + df = DF.copy() + df["Yes"] = (np.random.default_rng(1).random(len(df)) < 0.4).astype(int) + proportional = load(df, idx=("L1", "L3"), x="Level", y="Yes", proportional=True, + cluster_col="ID", resamples=300) + for effect_size in ("mean_diff", "cohens_h"): + assert getattr(proportional, effect_size).results["ci_expanded"].iloc[0] > 95 + + assert clustered.mean_diff.plot(show_baseline_ec=True) is not None + plt.close("all") + + +def test_unexpanded_limits_are_reported_alongside_the_expanded_ones(clustered, naive): + expanded = clustered.mean_diff.results + unexpanded = load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS).mean_diff.results + + # The unexpanded limits are the limits the interval would have without + # expansion, and lie inside the expanded interval. + for kind in ("bca", "pct", "bec_bca", "bec_pct"): + for side in ("low", "high"): + assert expanded[f"{kind}_{side}_unexpanded"].to_numpy() == pytest.approx( + unexpanded[f"{kind}_{side}"].to_numpy()), (kind, side) + assert (expanded[f"{kind}_low"] <= expanded[f"{kind}_low_unexpanded"]).all() + assert (expanded[f"{kind}_high_unexpanded"] <= expanded[f"{kind}_high"]).all() + + # The same values are available on the effect size object. + control, test = DF["Level"] == "L1", DF["Level"] == "L2" + two_groups = TwoGroupsEffectSize( + DF.loc[control, "Y"].to_numpy(), DF.loc[test, "Y"].to_numpy(), "mean_diff", + is_paired="sequential", resamples=PAIRED_KWARGS["resamples"], permutation_count=10, + control_clusters=DF.loc[control, "ID"].to_numpy(), test_clusters=DF.loc[test, "ID"].to_numpy()) + assert two_groups.bca_low <= two_groups.bca_low_unexpanded < two_groups.bca_high_unexpanded <= two_groups.bca_high + assert two_groups.pct_low <= two_groups.pct_low_unexpanded < two_groups.pct_high_unexpanded <= two_groups.pct_high + + # Nothing to report when the interval is not expanded. + for results in (unexpanded, naive.mean_diff.results): + assert not any("unexpanded" in c for c in results.columns) + + # Delta-delta and mini-meta. + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + delta2_kwargs = dict(x=["Level", "Env"], y="Y", delta2=True, experiment="Env", paired="sequential", + id_col="pair", cluster_col="ID", resamples=500) + mini_meta = load(df, idx=(("L1", "L3"),), x="Level", y="Y", mini_meta=True, paired="sequential", + id_col="pair", cluster_col="ID", resamples=500) + for obj in (load(df, **delta2_kwargs).mean_diff.delta_delta, mini_meta.mean_diff.mini_meta): + assert obj.bca_low <= obj.bca_low_unexpanded < obj.bca_high_unexpanded <= obj.bca_high + assert obj.pct_low <= obj.pct_low_unexpanded < obj.pct_high_unexpanded <= obj.pct_high + assert {"bca_low_unexpanded", "pct_high_unexpanded"} <= set(obj.results.columns) + off = load(df, cluster_ci_expansion=False, **delta2_kwargs).mean_diff.delta_delta + assert off.bca_low_unexpanded is None + assert not any("unexpanded" in c for c in off.results.columns) + + +def _ci_segments(ax, horizontal=False): + """(position, low, high, linewidth) of every straight line drawn along the effect size axis.""" + segments = [] + for line in ax.get_lines(): + x = np.asarray(line.get_xdata(), dtype=float) + y = np.asarray(line.get_ydata(), dtype=float) + along, across = (y, x) if horizontal else (x, y) + if len(along) == 2 and along[0] == along[1] and across[0] != across[1]: + segments.append((along[0], across.min(), across.max(), line.get_linewidth())) + return sorted(segments) + + +def test_plots_draw_the_expansion_as_a_thinner_line(clustered, naive): + import matplotlib + import matplotlib.pyplot as plt + + matplotlib.use("Agg") + results = clustered.mean_diff.results + + # At each contrast a thin line spans the expanded interval, and a thick bar + # the unexpanded interval, which the bootstrap distribution spans. + fig = clustered.mean_diff.plot() + segments = _ci_segments(fig.axes[1]) + for j, row in enumerate(results.itertuples(), start=1): + at_j = [s for s in segments if s[0] == j] + assert len(at_j) == 2 + thin, thick = sorted(at_j, key=lambda s: s[3]) + assert thin[3] < thick[3] + assert (thin[1], thin[2]) == pytest.approx((row.bca_low, row.bca_high)) + assert (thick[1], thick[2]) == pytest.approx((row.bca_low_unexpanded, row.bca_high_unexpanded)) + plt.close("all") + + # The percentile interval, horizontal plots and custom styling of the thin line. + fig = clustered.mean_diff.plot(ci_type="pct", horizontal=True, + contrast_expanded_errorbar_kwargs={"color": "red", "lw": 1.5}) + ax = fig.axes[1] + thin = [line for line in ax.get_lines() if line.get_color() == "red"] + assert thin and all(line.get_linewidth() == 1.5 for line in thin) + thin = sorted(s for s in _ci_segments(ax, horizontal=True) if s[3] == 1.5) + assert [(lo, hi) for _, lo, hi, _ in thin] == pytest.approx(list(zip(results.pct_low, results.pct_high))) + plt.close("all") + + # One whisker per contrast when the interval is not expanded. + opted_out = load(DF, cluster_col="ID", cluster_ci_expansion=False, **PAIRED_KWARGS) + for obj in (naive, opted_out): + segments = _ci_segments(obj.mean_diff.plot().axes[1]) + assert len({s[3] for s in segments}) == 1 + assert sorted(s[0] for s in segments) == [1.0, 2.0] + plt.close("all") + + # The baseline error curve and delta-delta are drawn the same way. + fig = clustered.mean_diff.plot(show_baseline_ec=True) + assert len([s for s in _ci_segments(fig.axes[1]) if s[0] == 0]) == 2 + plt.close("all") + df = DF[DF["Level"].isin(["L1", "L3"])].copy() + df["Env"] = np.where(df["pair"] % 4 < 2, "A", "B") + delta2 = load(df, x=["Level", "Env"], y="Y", delta2=True, experiment="Env", paired="sequential", + id_col="pair", cluster_col="ID", resamples=500) + dd = delta2.mean_diff.delta_delta + drawn = [(lo, hi) for _, lo, hi, _ in _ci_segments(delta2.mean_diff.plot().axes[1])] + assert any((lo, hi) == pytest.approx((dd.bca_low, dd.bca_high)) for lo, hi in drawn) + assert any((lo, hi) == pytest.approx((dd.bca_low_unexpanded, dd.bca_high_unexpanded)) for lo, hi in drawn) + plt.close("all") + + +def test_forest_plot_draws_the_expansion_as_a_thinner_line(clustered, naive): + import matplotlib + import matplotlib.pyplot as plt + from dabest import forest_plot + + matplotlib.use("Agg") + results = clustered.mean_diff.results.iloc[0] + for horizontal in (False, True): + fig = forest_plot([clustered, naive], idx=[[0], [0]], labels=["clustered", "naive"], horizontal=horizontal) + segments = _ci_segments(fig.axes[0], horizontal=horizontal) + at_1 = sorted((s for s in segments if s[0] == 1), key=lambda s: s[3]) + assert len(at_1) == 2 + assert (at_1[0][1], at_1[0][2]) == pytest.approx((results.bca_low, results.bca_high)) + assert (at_1[1][1], at_1[1][2]) == pytest.approx((results.bca_low_unexpanded, results.bca_high_unexpanded)) + assert len([s for s in segments if s[0] == 2]) == 1 + plt.close("all") diff --git a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb index de380b59..a3921c99 100644 --- a/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb +++ b/nbs/tutorials/03-shared_control_and_repeated_measures.ipynb @@ -638,6 +638,409 @@ "multi_baseline_repeated_measures.mean_diff.plot();" ] }, + { + "cell_type": "markdown", + "id": "3e06bc8e", + "metadata": {}, + "source": [ + "## Cluster-correlated data: several pairs per participant\n", + "\n", + "The repeated-measures plots above assume that every row of `id_col` is an\n", + "independent pair. In many within-subjects experiments, however, each\n", + "participant contributes *several* sets of paired observations, for example\n", + "by rating several stimuli under each condition. Pairs from the same\n", + "participant are then correlated, and resampling them as if they were\n", + "independent (a form of pseudoreplication) produces confidence intervals\n", + "that are too narrow and permutation p-values that are too small.\n", + "\n", + "`dabest.load()` handles this with the `cluster_col` argument, which names the\n", + "column identifying the independent sampling unit (the *cluster*, here the\n", + "participant) that every observation belongs to. `id_col` still identifies\n", + "the pairs, and `cluster_col` identifies the units the pairs are nested in:\n", + "\n", + "- the bootstrap resamples whole participants with replacement, keeping all\n", + " of a participant's pairs together (a *cluster bootstrap*), and\n", + "- the permutation test swaps control and test labels for whole participants\n", + " at a time.\n", + "\n", + "Every pair must belong to a single cluster. `cluster_col` also works for\n", + "unpaired data, where a participant may contribute several observations to\n", + "each group. The parametric and rank-based tests reported by\n", + "`.statistical_tests` are unchanged and still treat every observation as\n", + "independent, so prefer the bootstrap interval and the permutation p-value\n", + "when the data are clustered.\n", + "\n", + "Let us simulate such an experiment, in which each participant's sensitivity\n", + "to the treatment varies:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "97e41158", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParticipantPairConditionScore
0P000Control3.308213
1P000Test 14.157010
2P000Test 25.310708
3P000Test 36.217601
4P001Control1.292431
5P001Test 12.661625
6P001Test 23.387853
7P001Test 34.506913
\n", + "
" + ], + "text/plain": [ + " Participant Pair Condition Score\n", + "0 P00 0 Control 3.308213\n", + "1 P00 0 Test 1 4.157010\n", + "2 P00 0 Test 2 5.310708\n", + "3 P00 0 Test 3 6.217601\n", + "4 P00 1 Control 1.292431\n", + "5 P00 1 Test 1 2.661625\n", + "6 P00 1 Test 2 3.387853\n", + "7 P00 1 Test 3 4.506913" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(2024)\n", + "\n", + "n_participants, n_stimuli = 15, 5\n", + "conditions = [\"Control\", \"Test 1\", \"Test 2\", \"Test 3\"]\n", + "rows = []\n", + "for participant in range(n_participants):\n", + " sensitivity = np.random.normal(1, 0.4) # participant-specific response to the treatment\n", + " for stimulus in range(n_stimuli):\n", + " baseline = np.random.normal(3, 0.5)\n", + " for k, condition in enumerate(conditions):\n", + " rows.append({\"Participant\": \"P{:02d}\".format(participant),\n", + " \"Pair\": participant * n_stimuli + stimulus,\n", + " \"Condition\": condition,\n", + " \"Score\": baseline + 0.5 * k * sensitivity + np.random.normal(0, 0.3)})\n", + "\n", + "clustered_df = pd.DataFrame(rows)\n", + "clustered_df.head(8)" + ] + }, + { + "cell_type": "markdown", + "id": "c2dda2ee", + "metadata": {}, + "source": [ + "Loading the data with `id_col` alone treats the 75 pairs as independent.\n", + "Adding `cluster_col=\"Participant\"` resamples the 15 participants instead:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a33a5d4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DABEST v2025.10.20\n", + "==================\n", + " \n", + "Good evening!\n", + "The current time is Sun Sep 27 22:55:50 2026.\n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Control and Test 1 is 0.589 [95%CI 0.432, 0.764].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Control and Test 2 is 1.24 [95%CI 0.975, 1.51].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Control and Test 3 is 1.78 [95%CI 1.38, 2.17].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0, calculated for legacy purposes only. \n", + "\n", + "5000 cluster bootstrap samples were taken, resampling 15 clusters with replacement; the confidence interval is bias-corrected and accelerated, and expanded for the small number of clusters\n", + "(the 95% interval is read at the 97.36% level of the bootstrap distribution).\n", + "Any p-value reported is the probability of observing theeffect size (or greater),\n", + "assuming the null hypothesis of zero difference is true.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed at the level of whole clusters.\n", + "\n", + "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pairs_only = dabest.load(clustered_df, idx=(\"Control\", \"Test 1\", \"Test 2\", \"Test 3\"),\n", + " x=\"Condition\", y=\"Score\",\n", + " paired=\"baseline\", id_col=\"Pair\")\n", + "\n", + "by_participant = dabest.load(clustered_df, idx=(\"Control\", \"Test 1\", \"Test 2\", \"Test 3\"),\n", + " x=\"Condition\", y=\"Score\",\n", + " paired=\"baseline\", id_col=\"Pair\",\n", + " cluster_col=\"Participant\")\n", + "\n", + "by_participant.mean_diff" + ] + }, + { + "cell_type": "markdown", + "id": "b7565cc1", + "metadata": {}, + "source": [ + "The paired mean differences are identical, but the cluster-aware confidence\n", + "intervals are wider because they reflect the between-participant variation\n", + "in the treatment effect. With only 15 participants they are also expanded\n", + "slightly, by default, to keep their coverage close to 95% (the printed output\n", + "gives the level at which the bootstrap distribution is read, also reported in\n", + "the `ci_expanded` column; see the\n", + "[Cluster-Robust Bootstrap tutorial](11-cluster_robust_bootstrap.html#few-clusters-the-small-sample-expansion),\n", + "and pass `cluster_ci_expansion=False` to turn this off). In the plot below, this expansion is the thin\n", + "line that extends each interval beyond its usual thick bar. The number of clusters resampled is reported in the\n", + "`n_clusters` column of the results:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3953893f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
controltestdifferencebca_lowbca_highpvalue_permutationn_clusters
pairs resampled (id_col only)0ControlTest 10.5886220.4798060.6967050.0NaN
1ControlTest 21.2416031.1077751.3864820.0NaN
2ControlTest 31.7788281.6062551.9577610.0NaN
participants resampled (cluster_col)0ControlTest 10.5886220.4320370.7642880.015.0
1ControlTest 21.2416030.9748801.5145030.015.0
2ControlTest 31.7788281.3792952.1651350.015.0
\n", + "
" + ], + "text/plain": [ + " control ... n_clusters\n", + "pairs resampled (id_col only) 0 Control ... NaN\n", + " 1 Control ... NaN\n", + " 2 Control ... NaN\n", + "participants resampled (cluster_col) 0 Control ... 15.0\n", + " 1 Control ... 15.0\n", + " 2 Control ... 15.0\n", + "\n", + "[6 rows x 7 columns]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "columns = [\"control\", \"test\", \"difference\", \"bca_low\", \"bca_high\", \"pvalue_permutation\"]\n", + "pd.concat({\"pairs resampled (id_col only)\": pairs_only.mean_diff.results[columns],\n", + " \"participants resampled (cluster_col)\": by_participant.mean_diff.results[columns + [\"n_clusters\"]]})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db75c6cb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "by_participant.mean_diff.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "2fbb942d", + "metadata": {}, + "source": [ + "For a deeper look at why this matters, including a simulation showing how often each method's confidence interval actually contains a known true effect, see the [Cluster-Robust Bootstrap for Repeated Measures](11-cluster_robust_bootstrap.html) tutorial." + ] + }, { "cell_type": "markdown", "id": "9a08d862", diff --git a/nbs/tutorials/08-plot_aesthetics.ipynb b/nbs/tutorials/08-plot_aesthetics.ipynb index 5d20a4aa..f730c00c 100644 --- a/nbs/tutorials/08-plot_aesthetics.ipynb +++ b/nbs/tutorials/08-plot_aesthetics.ipynb @@ -2107,13 +2107,19 @@ }, { "cell_type": "markdown", - "id": "e3969990", + "id": "a07fa970", "metadata": {}, "source": [ "## Baseline error curve\n", "\n", - "In DABEST **v2025.03.27**, we introduce a new aspect to the contrast axes: the baseline dot and error curve. \n", - "While the baseline dot is always present, the error curve can be turned on by setting `show_baseline_ec=True` in the `.plot()` method." + "In DABEST **v2025.03.27**, we introduced a new aspect to the contrast axes: the baseline dot and error curve.\n", + "While the baseline dot is always present, the error curve can be turned on by setting `show_baseline_ec=True` in the `.plot()` method.\n", + "\n", + "The baseline error curve (bec) is a *reference*, not a second comparison. For the leftmost (\"control\") group of\n", + "each `idx` tuple, DABEST draws bootstrap resamples of that group and compares them to independent bootstrap\n", + "resamples of the very same group, giving a bootstrap distribution centred on 0 whose spread reflects the sampling\n", + "noise inherent to that group alone. It is a visual gauge for \"how wide would a comparison look if there were no\n", + "effect at all\", which the real effect-size curves can be judged against." ] }, { @@ -2136,6 +2142,109 @@ "source": [ "repeated_measures.mean_diff.plot(show_baseline_ec=True); " ] + }, + { + "cell_type": "markdown", + "id": "558d2349", + "metadata": {}, + "source": [ + "A key detail, not obvious from the plot alone: **the bec is always computed as an unpaired comparison**,\n", + "even when the main analysis uses `paired=\"baseline\"` or `paired=\"sequential\"`. This is because the bec stands in\n", + "for \"no relationship between the two sides\", so pairing (which assumes a real, shared relationship) would not\n", + "make sense for it. For most datasets this distinction barely matters and the bec looks like a modest reference\n", + "band, as above.\n", + "\n", + "### Baseline error curve with clustered (repeated-measures) data\n", + "\n", + "The unpaired-only nature of the bec interacts with `cluster_col` (see the\n", + "[Shared Control & Repeated Measures tutorial](03-shared_control_and_repeated_measures.html#cluster-correlated-data-several-pairs-per-participant))\n", + "in a way worth knowing about. When a participant contributes several pairs of observations, the *real* paired\n", + "effect-size curves mostly cancel out each participant's own baseline level, so cluster-aware resampling barely\n", + "widens them. The bec gets no such cancellation, because it is always unpaired: it resamples whole participants\n", + "against an independent resample of the same participants, so its width is set by how much participants differ\n", + "from each other, divided by the number of participants, rather than by the number of rows. If participants vary\n", + "a lot in their average response, the bec can become far wider than the real contrasts once `cluster_col` is set,\n", + "even though nothing is wrong with either curve. Rescale `contrast_ylim` to fit it, or set `show_baseline_ec=False`\n", + "for plots where the reference curve is not the point.\n", + "\n", + "Let's demonstrate with a small repeated-measures dataset where 15 participants each contribute 3 pairs of\n", + "observations, and participants vary considerably in their average score:\n", + "\n", + "For a simulation-based demonstration of why `cluster_col` matters for the real comparisons too, not just the baseline curve, see the [Cluster-Robust Bootstrap for Repeated Measures](11-cluster_robust_bootstrap.html) tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae800dbf", + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(101)\n", + "\n", + "n_participants, n_pairs = 15, 3\n", + "participant_level = np.random.normal(0, 1.2, n_participants) # participants differ a lot from each other\n", + "\n", + "rows = []\n", + "for p in range(n_participants):\n", + " for s in range(n_pairs):\n", + " rows.append({\"Participant\": \"P{:02d}\".format(p),\n", + " \"Pair\": p * n_pairs + s,\n", + " \"Control\": 3 + participant_level[p] + np.random.normal(0, 0.4),\n", + " \"Test\": 3 + participant_level[p] + 0.5 + np.random.normal(0, 0.4)})\n", + "\n", + "bec_demo_df = pd.DataFrame(rows)\n", + "\n", + "bec_demo_naive = dabest.load(bec_demo_df, idx=(\"Control\", \"Test\"),\n", + " paired=\"baseline\", id_col=\"Pair\")\n", + "bec_demo_clustered = dabest.load(bec_demo_df, idx=(\"Control\", \"Test\"),\n", + " paired=\"baseline\", id_col=\"Pair\",\n", + " cluster_col=\"Participant\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "adc27763", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# `float_contrast=False` is used here so the baseline dot and error curve\n", + "# (plotted at the \"Control\" position) share the same axis as the real\n", + "# comparison, rather than the default floating Gardner-Altman axis, which\n", + "# only has room for the single \"Test minus Control\" delta.\n", + "f, axx = plt.subplots(ncols=2, figsize=(11, 5), gridspec_kw={\"wspace\": 0.35})\n", + "\n", + "bec_demo_naive.mean_diff.plot(show_baseline_ec=True, float_contrast=False, ax=axx[0],\n", + " contrast_ylim=(-1.5, 1.5), title=\"id_col only\");\n", + "bec_demo_clustered.mean_diff.plot(show_baseline_ec=True, float_contrast=False, ax=axx[1],\n", + " contrast_ylim=(-1.5, 1.5), title=\"id_col + cluster_col\");" + ] + }, + { + "cell_type": "markdown", + "id": "c900d30e", + "metadata": {}, + "source": [ + "The real paired mean difference (the black dot and violin above \"Test minus Control\") is nearly\n", + "identical between the two plots. The baseline error curve at the \"Control\" position, however, is visibly wider\n", + "once `cluster_col` accounts for the fact that these 15 participants (not 45 independent pairs) are the real\n", + "resampling unit — and at higher between-participant variance, or with a stronger effect of participant count, it\n", + "can extend beyond a `contrast_ylim` that comfortably fits the real contrasts. (The thin lines extending the\n", + "intervals in the right-hand plot are the small-sample expansion that `cluster_col` applies by default; see the\n", + "[Cluster-Robust Bootstrap tutorial](11-cluster_robust_bootstrap.html#few-clusters-the-small-sample-expansion).)" + ] } ], "metadata": { diff --git a/nbs/tutorials/11-cluster_robust_bootstrap.ipynb b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb new file mode 100644 index 00000000..bc603643 --- /dev/null +++ b/nbs/tutorials/11-cluster_robust_bootstrap.ipynb @@ -0,0 +1,858 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8cca6a3d", + "metadata": {}, + "source": [ + "# Cluster-Robust Bootstrap for Repeated Measures\n", + "\n", + "> A worked, simulation-based example of `cluster_col`, for designs where a single participant contributes several sets of paired observations.\n", + "\n", + "- order: 11" + ] + }, + { + "cell_type": "markdown", + "id": "b65c5815", + "metadata": {}, + "source": [ + "## The problem: pairs nested within participants\n", + "\n", + "DABEST's `paired` and `id_col` arguments handle the common repeated-measures case where every\n", + "participant contributes exactly one paired observation (one row of `id_col`). Some experiments,\n", + "though, ask each participant to provide *several* paired comparisons: several stimuli rated under\n", + "each of two conditions, several trials of a before/after manipulation, and so on. A common\n", + "workaround is to build a \"dummy\" pairing ID for each set, for example with\n", + "\n", + "```python\n", + "data[\"dummyID\"] = data.groupby([\"ParticipantID\", \"OtherGroupingVars\"]).ngroup()\n", + "```\n", + "\n", + "so that `id_col=\"dummyID\"` pairs each set correctly. This gets the *point estimate* right: an\n", + "average of several valid within-participant differences is still an unbiased estimate of the\n", + "average effect. It does not get the *uncertainty* right, because the bootstrap has no way of\n", + "knowing that several dummy IDs came from the same participant. It resamples dummy IDs as if\n", + "they were independent, which is a form of pseudoreplication: participants who happen to be drawn\n", + "more than once contribute more than once to a resample, but their sets are correlated with each\n", + "other, not independent new evidence, so the resulting interval is typically too narrow.\n", + "\n", + "`cluster_col` fixes this by naming the column that identifies the actual independent sampling\n", + "unit (the participant). With it set, the bootstrap resamples whole participants with replacement,\n", + "keeping all of a participant's sets together in every resample, and the permutation test\n", + "reshuffles labels at the participant level too. See the\n", + "[Shared Control & Repeated Measures tutorial](03-shared_control_and_repeated_measures.html#cluster-correlated-data-several-pairs-per-participant)\n", + "for the basic mechanics, and the\n", + "[Plot Aesthetics tutorial](08-plot_aesthetics.html#baseline-error-curve-with-clustered-repeated-measures-data)\n", + "for how it interacts with the baseline error curve. This tutorial instead focuses on *why it\n", + "matters*: because we simulate the data ourselves, we know the true effect, and can check directly\n", + "whether each method's confidence interval actually contains it as often as it claims to." + ] + }, + { + "cell_type": "markdown", + "id": "3a17decd", + "metadata": {}, + "source": [ + "## Load libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6473d3d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-compiling numba functions for DABEST...\n", + "Numba compilation complete!\n", + "We're using DABEST v2025.10.20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "Compiling numba functions: 0%| | 0/13 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ParticipantStimSetConditionRating
0P000Treatment6.712673
1P000Baseline5.611588
2P001Treatment7.069194
3P001Baseline5.483891
4P002Treatment6.523818
5P002Baseline5.515261
6P003Treatment6.771716
7P003Baseline5.460908
\n", + "" + ], + "text/plain": [ + " Participant StimSet Condition Rating\n", + "0 P00 0 Treatment 6.712673\n", + "1 P00 0 Baseline 5.611588\n", + "2 P00 1 Treatment 7.069194\n", + "3 P00 1 Baseline 5.483891\n", + "4 P00 2 Treatment 6.523818\n", + "5 P00 2 Baseline 5.515261\n", + "6 P00 3 Treatment 6.771716\n", + "7 P00 3 Baseline 5.460908" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(2024)\n", + "\n", + "n_participants = 15\n", + "n_stimuli = 6 # each participant rates 6 different stimuli per condition\n", + "true_effect = 0.3 # average Treatment-minus-Baseline effect: modest, relative to how much participants vary\n", + "participant_sd = 1.4 # how much participants differ in their OWN sensitivity to the treatment: considerable\n", + "noise_sd = 0.6 # trial-to-trial measurement noise\n", + "\n", + "sensitivity = np.random.normal(1, participant_sd, n_participants)\n", + "\n", + "rows = []\n", + "for p in range(n_participants):\n", + " for s in range(n_stimuli):\n", + " stim_baseline = np.random.normal(5, 1.0) # this stimulus's baseline level for this participant\n", + " rows.append({\"Participant\": \"P{:02d}\".format(p), \"StimSet\": p * n_stimuli + s,\n", + " \"Condition\": \"Baseline\",\n", + " \"Rating\": stim_baseline + np.random.normal(0, noise_sd)})\n", + " rows.append({\"Participant\": \"P{:02d}\".format(p), \"StimSet\": p * n_stimuli + s,\n", + " \"Condition\": \"Treatment\",\n", + " \"Rating\": stim_baseline + true_effect * sensitivity[p] + np.random.normal(0, noise_sd)})\n", + "\n", + "sim_df = pd.DataFrame(rows).sort_values([\"StimSet\", \"Condition\"], ascending=[True, False]).reset_index(drop=True)\n", + "print(\"{} rows, {} participants, {} paired sets\".format(len(sim_df), sim_df[\"Participant\"].nunique(), sim_df[\"StimSet\"].nunique()))\n", + "sim_df.head(8)" + ] + }, + { + "cell_type": "markdown", + "id": "400d2a9f", + "metadata": {}, + "source": [ + "## The dummy-ID (naive) analysis\n", + "\n", + "This is exactly the workflow described above: `id_col=\"StimSet\"` correctly pairs each of the 90\n", + "sets, with no mention yet of which participant each set belongs to." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61fe4aed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DABEST v2025.10.20\n", + "==================\n", + " \n", + "Good evening!\n", + "The current time is Sun Sep 27 22:55:36 2026.\n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Baseline and Treatment is 0.35 [95%CI 0.132, 0.568].\n", + "The p-value of the two-sided permutation t-test is 0.0026, calculated for legacy purposes only. \n", + "\n", + "5000 bootstrap samples were taken; the confidence interval is bias-corrected and accelerated.\n", + "Any p-value reported is the probability of observing theeffect size (or greater),\n", + "assuming the null hypothesis of zero difference is true.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed.\n", + "\n", + "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "naive = dabest.load(sim_df, idx=(\"Baseline\", \"Treatment\"),\n", + " x=\"Condition\", y=\"Rating\",\n", + " paired=\"baseline\", id_col=\"StimSet\",\n", + " resamples=5000, random_seed=2024)\n", + "naive.mean_diff" + ] + }, + { + "cell_type": "markdown", + "id": "05ef4c09", + "metadata": {}, + "source": [ + "## Adding `cluster_col`\n", + "\n", + "The only change is one extra argument, naming the column that identifies each participant. The\n", + "pairing (`id_col`) is unchanged, since the sets themselves are still correctly paired; only the\n", + "*resampling unit* changes, from \"one set\" to \"one participant, and all their sets together\".\n", + "\n", + "By default, `cluster_col` also widens the confidence interval slightly to allow for the small\n", + "number of clusters. The printed output says so (\"the 95% interval is read at the ...% level of the\n", + "bootstrap distribution\"); the [section on few clusters](#few-clusters-the-small-sample-expansion)\n", + "below explains why." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af815b94", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DABEST v2025.10.20\n", + "==================\n", + " \n", + "Good evening!\n", + "The current time is Sun Sep 27 22:55:36 2026.\n", + "\n", + "The paired mean difference for repeated measures against baseline \n", + "between Baseline and Treatment is 0.35 [95%CI -0.184, 0.676].\n", + "The p-value of the two-sided cluster-level permutation test is 0.0866, calculated for legacy purposes only. \n", + "\n", + "5000 cluster bootstrap samples were taken, resampling 15 clusters with replacement; the confidence interval is bias-corrected and accelerated, and expanded for the small number of clusters\n", + "(the 95% interval is read at the 97.36% level of the bootstrap distribution).\n", + "Any p-value reported is the probability of observing theeffect size (or greater),\n", + "assuming the null hypothesis of zero difference is true.\n", + "For each p-value, 5000 reshuffles of the control and test labels were performed at the level of whole clusters.\n", + "\n", + "To get the results of all valid statistical tests, use `.mean_diff.statistical_tests`" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clustered = dabest.load(sim_df, idx=(\"Baseline\", \"Treatment\"), x=\"Condition\", y=\"Rating\",\n", + " paired=\"baseline\", id_col=\"StimSet\", cluster_col=\"Participant\",\n", + " resamples=5000, random_seed=2024)\n", + "clustered.mean_diff" + ] + }, + { + "cell_type": "markdown", + "id": "c4a70a83", + "metadata": {}, + "source": [ + "Side by side, the point estimate is identical and the interval is wider once `cluster_col` accounts for the fact that 15 participants, not 90 sets, are the real resampling unit:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "64e293da", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
controltestdifferencebca_lowbca_highpvalue_permutationn_clusters
id_col only (naive)0BaselineTreatment0.3495310.1317640.5681420.0026NaN
id_col + cluster_col0BaselineTreatment0.349531-0.1843060.6758240.086615.0
\n", + "
" + ], + "text/plain": [ + " control test ... pvalue_permutation n_clusters\n", + "id_col only (naive) 0 Baseline Treatment ... 0.0026 NaN\n", + "id_col + cluster_col 0 Baseline Treatment ... 0.0866 15.0\n", + "\n", + "[2 rows x 7 columns]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compare_cols = [\"control\", \"test\", \"difference\", \"bca_low\", \"bca_high\", \"pvalue_permutation\"]\n", + "pd.concat({\n", + " \"id_col only (naive)\": naive.mean_diff.results[compare_cols],\n", + " \"id_col + cluster_col\": clustered.mean_diff.results[compare_cols + [\"n_clusters\"]],\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "3619c6bf", + "metadata": {}, + "source": [ + "To see that difference clearly, we turn off the delta dots (the per-pair swarm on the contrast\n", + "axis, on by default) and the lines connecting them, since with 90 of them they mostly obscure the\n", + "interval; switch off the floating Gardner-Altman layout so the contrast axis gets its own,\n", + "independently-scaled y-axis rather than one stretched to match the raw data panel above it; zoom\n", + "that axis to the two intervals themselves, since both otherwise sit inside a small fraction of the\n", + "default axis range; and annotate each panel with its own `[bca_low, bca_high]` directly, so the\n", + "numbers don't have to be read off the axis at all." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7580ef30", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bounds = pd.concat([naive.mean_diff.results[[\"bca_low\", \"bca_high\"]],\n", + " clustered.mean_diff.results[[\"bca_low\", \"bca_high\"]]])\n", + "shared_ylim = (bounds.bca_low.min() - 0.35, bounds.bca_high.max() + 0.35)\n", + "palette = {\"Baseline\": \"#4C72B0\", \"Treatment\": \"#C44E52\"} # a non-neutral palette\n", + "\n", + "f, axx = plt.subplots(ncols=2, figsize=(11, 5),\n", + " gridspec_kw={\"wspace\": 0.45})\n", + "for ax, dabest_obj, title in [(axx[0], naive, \"id_col only\"),\n", + " (axx[1], clustered, \"id_col + cluster_col\")]:\n", + " dabest_obj.mean_diff.plot(ax=ax, delta_dot=False,\n", + " contrast_paired_lines=False,\n", + " float_contrast=False,\n", + " custom_palette=palette,\n", + " contrast_marker_size=8,\n", + " contrast_ylim=shared_ylim,\n", + " title=title)\n", + "\n", + " result = dabest_obj.mean_diff.results.iloc[0]\n", + " tick = ax.contrast_axes.get_xticks()[-1]\n", + " ax.contrast_axes.text(tick, result.bca_low - 0.3,\n", + " \"[{:.2f}, {:.2f}]\".format(result.bca_low, result.bca_high),\n", + " ha=\"center\", va=\"bottom\", fontsize=10.5, fontweight=\"bold\")" + ] + }, + { + "cell_type": "markdown", + "id": "226c013d", + "metadata": {}, + "source": [ + "Inspect the two bracketed intervals: the cluster-naive one sits entirely above 0, while the\n", + "cluster-aware one spans across the zero line. This could impact on the conclusions drawn from the estimation plot.\n", + "Same data, same point estimate, opposite verdict at the conventional 5% threshold. Treating each dummy ID as an independent participant could lead to reporting more certainty in an effect size than is warranted by the data, once cluster-correlation is accounted for in resampling. This is the practical implication of the pseudoreplication concern that motivates `cluster_col`." + ] + }, + { + "cell_type": "markdown", + "id": "edf41cc1", + "metadata": {}, + "source": [ + "## Does it matter for real inference? A coverage check\n", + "\n", + "One worked example makes the risk concrete, but could this particular result be a fluke of this\n", + "particular random dataset? Because this dataset is simulated, we know the true effect\n", + "(`true_effect = 0.3`) exactly. That\n", + "lets us ask the question a single dataset can't answer: across many independent samples from the\n", + "same population, how often does each method's 95% interval actually contain the true effect? A\n", + "trustworthy 95% interval should hit close to 95% of the time; consistently missing more often\n", + "than that means the interval is too narrow to be trusted.\n", + "\n", + "We repeat the simulation above 200 times with fresh random data each time, and compute both a\n", + "naive and a cluster-aware bootstrap interval for each dataset, calling the same lower-level\n", + "functions that `dabest.load()` uses internally, so that the whole comparison runs in a few\n", + "seconds instead of a few minutes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "992fc77c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
95% CI covers the true effectmean CI width
method
id_col only (naive)0.8150.382
id_col + cluster_col, cluster_ci_expansion=False0.9000.511
id_col + cluster_col (default, expanded)0.9450.577
\n", + "
" + ], + "text/plain": [ + " 95% CI covers the true effect mean CI width\n", + "method \n", + "id_col only (naive) 0.815 0.382\n", + "id_col + cluster_col, cluster_ci_expansion=False 0.900 0.511\n", + "id_col + cluster_col (default, expanded) 0.945 0.577" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dabest._stats_tools import confint_2group_diff as ci2g\n", + "\n", + "def simulate_dataset(seed, n_participants=15, n_stimuli=6, true_effect=0.3,\n", + " participant_sd=1.4, noise_sd=0.6):\n", + " rng = np.random.default_rng(seed)\n", + " sensitivity = rng.normal(1, participant_sd, n_participants)\n", + " control, test, cluster = [], [], []\n", + " for p in range(n_participants):\n", + " for s in range(n_stimuli):\n", + " stim_baseline = rng.normal(5, 1.0)\n", + " control.append(stim_baseline + rng.normal(0, noise_sd))\n", + " test.append(stim_baseline + true_effect * sensitivity[p] + rng.normal(0, noise_sd))\n", + " cluster.append(p)\n", + " return np.array(control), np.array(test), np.array(cluster)\n", + "\n", + "def percentile_ci(bootstraps, ci=95):\n", + " lo, hi = np.percentile(bootstraps, [(100 - ci) / 2, 100 - (100 - ci) / 2])\n", + " return lo, hi\n", + "\n", + "n_simulated_datasets = 200\n", + "resamples_per_dataset = 1000\n", + "true_effect = 0.3\n", + "\n", + "# Every participant contributes to both conditions, so the cluster bootstrap has a single\n", + "# stratum of 15 participants, and the expansion DABEST applies by default is the same for\n", + "# every dataset: it reads the bootstrap distribution at this level instead of at 95%.\n", + "expanded_level, _ = ci2g.expanded_ci_level(95, [(1.0, 15)])\n", + "\n", + "naive_hits = cluster_hits = expanded_hits = 0\n", + "naive_widths, cluster_widths, expanded_widths = [], [], []\n", + "\n", + "for seed in range(n_simulated_datasets):\n", + " control, test, cluster = simulate_dataset(seed, true_effect=true_effect)\n", + "\n", + " boot_naive = ci2g.compute_bootstrapped_diff(\n", + " control, test, \"baseline\", \"mean_diff\", resamples_per_dataset, seed)\n", + " boot_cluster = ci2g.compute_cluster_bootstrapped_diff(\n", + " control, test, cluster, cluster, \"baseline\", \"mean_diff\", resamples_per_dataset, seed)\n", + "\n", + " lo_n, hi_n = percentile_ci(boot_naive)\n", + " lo_c, hi_c = percentile_ci(boot_cluster)\n", + " lo_e, hi_e = percentile_ci(boot_cluster, ci=expanded_level)\n", + "\n", + " naive_hits += lo_n <= true_effect <= hi_n\n", + " cluster_hits += lo_c <= true_effect <= hi_c\n", + " expanded_hits += lo_e <= true_effect <= hi_e\n", + " naive_widths.append(hi_n - lo_n)\n", + " cluster_widths.append(hi_c - lo_c)\n", + " expanded_widths.append(hi_e - lo_e)\n", + "\n", + "coverage = pd.DataFrame({\n", + " \"method\": [\"id_col only (naive)\",\n", + " \"id_col + cluster_col, cluster_ci_expansion=False\",\n", + " \"id_col + cluster_col (default, expanded)\"],\n", + " \"95% CI covers the true effect\": [naive_hits / n_simulated_datasets,\n", + " cluster_hits / n_simulated_datasets,\n", + " expanded_hits / n_simulated_datasets],\n", + " \"mean CI width\": [np.mean(naive_widths), np.mean(cluster_widths), np.mean(expanded_widths)],\n", + "}).set_index(\"method\").round(3)\n", + "coverage" + ] + }, + { + "cell_type": "markdown", + "id": "cc4266e4", + "metadata": {}, + "source": [ + "With a nominal target of 95%, the naive dummy-ID bootstrap covers the true effect noticeably\n", + "less often than that across these 200 simulated datasets, because it cannot tell that groups of sets came from the same participant and so understates the true sampling uncertainty. Once `cluster_col` tells it, coverage recovers to close to the nominal 95%, at the cost of a correspondingly wider (but now trustworthy) interval.\n", + "\n", + "Similarly, the permutation test also yields p-values biased to be too small in the cluster-naive case; defining the `cluster_col` argument ensures permuation test is reshuffled at the cluster level, producing values that account for the cluster-correlation." + ] + }, + { + "cell_type": "markdown", + "id": "2e840a01", + "metadata": {}, + "source": [ + "## Few clusters: the small-sample expansion\n", + "\n", + "The middle row of the table shows what happens without one more ingredient. Resampling whole\n", + "participants removes the pseudoreplication, but with only 15 of them the cluster bootstrap is still a\n", + "little too narrow: coverage lands around 90% rather than 95%. This is a general property of\n", + "bootstrap intervals built from few independent units, not of clustering itself. The bootstrap\n", + "reproduces a variance with divisor n rather than n - 1, and normal rather than t-distributed tails.\n", + "\n", + "By default, whenever `cluster_col` is set, DABEST corrects for this with the *expanded percentile*\n", + "method of Hesterberg (2015, *The American Statistician*, 69(4), 371-386). The bootstrap distribution\n", + "itself is unchanged, and so is the half-violin in the plot, but each interval is read slightly further\n", + "into its tails. The reading uses a t distribution whose degrees of freedom come from the number of\n", + "clusters. When clusters are nested within groups, or appear in only some groups, those groups of\n", + "clusters are resampled independently, and their degrees of freedom are combined with the\n", + "Welch-Satterthwaite approximation. The bottom row shows that this restores close to nominal\n", + "coverage. Both the percentile and the bias-corrected and accelerated intervals are expanded, as are\n", + "those of the baseline error curve, delta-delta and mini-meta analyses.\n", + "\n", + "Because the half-violin still shows the same bootstrap distribution, plots draw an expanded interval\n", + "in two parts, as in the right-hand panel of the figure above. The thick bar spans the unexpanded 95%\n", + "interval of the plotted distribution, and a thinner line continues it out to the expanded limits\n", + "(the bracketed values). The thin extension is the allowance for having few participants; its style\n", + "can be changed with `contrast_expanded_errorbar_kwargs` in `.plot()`.\n", + "\n", + "The reported confidence level stays at 95%. The level at which the bootstrap distribution was\n", + "actually read is reported alongside it, in the `ci_expanded` column of the results, together with\n", + "the unexpanded limits drawn as the thick bar:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fab3e090", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
controltestn_clusterscici_expandedbca_low_unexpandedbca_high_unexpandedbca_lowbca_high
0BaselineTreatment159597.358565-0.1085570.639317-0.1843060.675824
\n", + "
" + ], + "text/plain": [ + " control test n_clusters ... bca_high_unexpanded bca_low bca_high\n", + "0 Baseline Treatment 15 ... 0.639317 -0.184306 0.675824\n", + "\n", + "[1 rows x 9 columns]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clustered.mean_diff.results[[\"control\", \"test\", \"n_clusters\", \"ci\", \"ci_expanded\",\n", + " \"bca_low_unexpanded\", \"bca_high_unexpanded\", \"bca_low\", \"bca_high\"]]" + ] + }, + { + "cell_type": "markdown", + "id": "e1266ac6", + "metadata": {}, + "source": [ + "The expansion fades as the number of clusters grows: with 15 participants the interval is read at\n", + "about the 97.4% level, with 30 at about 96.2%, and with 100 at about 95.4%. In simulations covering\n", + "paired and between-subject designs and every effect size DABEST offers, expanded intervals came within\n", + "about 3 percentage points of nominal coverage once there were at least 6 clusters in all and at\n", + "least 4 in each independently resampled group of clusters: for example 6 participants who each take\n", + "part in every condition, or 8 participants split between two conditions. With fewer, no bootstrap interval is\n", + "reliable: DABEST warns you, and the results are best treated as indicative. Because the expanded\n", + "interval is read further into the tails of the bootstrap distribution, it is also worth increasing\n", + "`resamples` (to 20000, say) when there are few clusters.\n", + "\n", + "If you prefer the unexpanded cluster-bootstrap interval, pass `cluster_ci_expansion=False` to\n", + "`dabest.load()`. That is appropriate only if you are confident the number of clusters is large enough\n", + "for the correction not to matter." + ] + }, + { + "cell_type": "markdown", + "id": "a2249805", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "- Use `cluster_col` whenever a real participant (or other independent unit) contributes more\n", + " than one row of `id_col`, whether the design is paired or unpaired.\n", + "- Ignoring clustering can lead to confidence intervals being estimated as too narrow.\n", + "- With `cluster_col` set, intervals are also expanded for the number of clusters by default, which\n", + " keeps their coverage close to nominal when there are few participants; the level actually read\n", + " is reported as `ci_expanded`, and `cluster_ci_expansion=False` turns this off. Plots draw the\n", + " expansion as a thinner line beyond the usual thick bar.\n", + "- The point estimate (the mean difference itself) is unaffected; only the bootstrap confidence intervals change, because they are the parts of the analysis that depend on which observations are treated as independent.\n", + "- The interval widens to reflect real between-participant variability that a cluster-naive bootstrap cannot account for. The example simulation above shows the naive interval can give a false sense of precision.\n", + "- Permutation tests are similarly reshuffled at the cluster-level, yielding larger values than the cluster-naive approach.\n", + "- The parametric and rank-based tests reported in `.statistical_tests` (Welch's t, Mann-Whitney, Wilcoxon, and so on) do not account for clustering and are unaffected by `cluster_col`; prefer the cluster-aware bootstrap interval for clustered data." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "refmap-psychoacoustics", + "language": "python", + "name": "refmap-psychoacoustics" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}