def _run_univariate_tests(self, X, y, control='N2', n_jobs=-1):
stats, pvals, _ = univariate_tests(
X, y, control=control, test=self.test,
comparison_type=self.comparison_type,
multitest_correction=self.multitest_method,
n_jobs=n_jobs)
effects = get_effect_sizes(
X, y, control=control, test=self.test,
comparison_type=self.comparison_type)
test_res = pd.DataFrame(pvals.min(axis=1), columns=['p-value'])
# In most cases, the pvals and effects have the same shape
# (when we do group-by-group comparisons, we get group-by-group
# effect sizes too, and when we do multi-class comparisons we get one
# effect size).
# But for the Kruskal-Wallis case, we cannot get one effect size for the
# test, so we get group-by-group effect sizes instead and keep the max.
# In this case pvals has only one column, but effects has more than one
# columns
if pvals.shape==effects.shape:
test_res['effect_size'] = effects.values[pvals.isin(pvals.min(axis=1)).values]
else:
test_res['effect_size'] = effects.max(axis=1)
self.test_results = test_res
return
def single_feature_window_mutant_worm_stats(metadata,
features,
save_dir,
window=2,
feature='motion_mode_paused_fraction',
pvalue_threshold=0.05,
fdr_method='fdr_by'):
""" T-tests comparing BW vs fepD for each mutant worm """
# 7 worm strains: N2 vs 'cat-2', 'eat-4', 'osm-5', 'pdfr-1', 'tax-2', 'unc-25'
# 2 bacteria strains: BW vs fepD
# 1 feature: 'motion_mode_paused_fraction'
# 1 window: 2 (corresponding to 30 minutes on food, just after first BL stimulus)
# focus on just one window = 30min just after BL (window=2)
window_metadata = metadata[metadata['window']==window]
# statistics: perform t-tests comparing fepD vs BW for each worm strain
worm_strain_list = list(window_metadata['worm_strain'].unique())
ttest_list = []
for worm in worm_strain_list:
worm_window_meta = window_metadata[window_metadata['worm_strain']==worm]
worm_window_feat = features[[feature]].reindex(worm_window_meta.index)
stats, pvals, reject = univariate_tests(X=worm_window_feat,
y=worm_window_meta['bacteria_strain'],
control='BW',
test='t-test',
comparison_type='binary_each_group',
multitest_correction=fdr_method,
alpha=PVAL_THRESH,
n_permutation_test=None)
# get effect sizes
effect_sizes = get_effect_sizes(X=worm_window_feat,
y=worm_window_meta['bacteria_strain'],
control='BW',
effect_type=None,
linked_test='t-test')
# compile t-test results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
effect_sizes.columns = ['effect_size_' + str(c) for c in effect_sizes.columns]
ttest_df = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
# record the worm strain as the index instead of the feature
ttest_df = ttest_df.rename(index={feature:worm})
ttest_list.append(ttest_df)
ttest_path = Path(save_dir) / 'pairwise_ttests' /\
'ttest_mutant_worm_fepD_vs_BW_window_{}_results.csv'.format(window)
ttest_path.parent.mkdir(exist_ok=True, parents=True)
ttest_results = pd.concat(ttest_list, axis=0)
ttest_results.to_csv(ttest_path, header=True, index=True)
return
def dead_keio_stats(features, metadata, args):
""" Perform statistical analyses on dead Keio experiment results:
- t-tests for each feature comparing each strain vs control for paired antioxidant treatment conditions
- t-tests for each feature comparing each strain antioxidant treatment to negative control (no antioxidant)
Inputs
------
features, metadata : pd.DataFrame
Clean feature summaries and accompanying metadata
args : Object
Python object with the following attributes:
- drop_size_features : bool
- norm_features_only : bool
- percentile_to_use : str
- remove_outliers : bool
- control_dict : dict
- n_top_feats : int
- tierpsy_top_feats_dir (if n_top_feats) : str
- test : str
- f_test : bool
- pval_threshold : float
- fdr_method : str
- n_sig_features : int
"""
print("\nInvestigating variation in worm behaviour on dead vs alive hit Keio strains")
# assert there will be no errors due to case-sensitivity
assert len(metadata[STRAIN_COLNAME].unique()) == len(metadata[STRAIN_COLNAME].str.upper().unique())
assert all(type(b) == np.bool_ for b in metadata[TREATMENT_COLNAME].unique())
# Load Tierpsy feature set + subset (columns) for selected features only
features = select_feat_set(features, 'tierpsy_{}'.format(args.n_top_feats), append_bluelight=True)
features = features[[f for f in features.columns if 'path_curvature' not in f]]
assert not features.isna().any().any()
#n_feats = features.shape[1]
strain_list = list(metadata[STRAIN_COLNAME].unique())
assert CONTROL_STRAIN in strain_list
# print mean sample size
sample_size = df_summary_stats(metadata, columns=[STRAIN_COLNAME, TREATMENT_COLNAME])
print("Mean sample size of %s: %d" % (STRAIN_COLNAME, int(sample_size['n_samples'].mean())))
# construct save paths (args.save_dir / topfeats? etc)
save_dir = get_save_dir(args)
stats_dir = save_dir / "Stats" / args.fdr_method
##### ANOVA #####
# make path to save ANOVA results
test_path = stats_dir / 'ANOVA_results.csv'
test_path.parent.mkdir(exist_ok=True, parents=True)
# ANOVA across strains for significant feature differences
if len(metadata[STRAIN_COLNAME].unique()) > 2:
stats, pvals, reject = univariate_tests(X=features,
y=metadata[STRAIN_COLNAME],
test='ANOVA',
control=CONTROL_STRAIN,
comparison_type='multiclass',
multitest_correction=None, # uncorrected
alpha=args.pval_threshold,
n_permutation_test=None) # 'all'
# get effect sizes
effect_sizes = get_effect_sizes(X=features,
y=metadata[STRAIN_COLNAME],
control=CONTROL_STRAIN,
effect_type=None,
linked_test='ANOVA')
# correct for multiple comparisons
reject_corrected, pvals_corrected = _multitest_correct(pvals,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save results (corrected)
test_results = pd.concat([stats, effect_sizes, pvals_corrected, reject_corrected], axis=1)
test_results.columns = ['stats','effect_size','pvals','reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path, header=True, index=True)
nsig = test_results['reject'].sum()
print("%d features (%.f%%) signficantly different among '%s'" % (nsig,
len(test_results.index)/nsig, STRAIN_COLNAME))
##### t-tests #####
for strain in strain_list:
strain_meta = metadata[metadata[STRAIN_COLNAME]==strain]
strain_feat = features.reindex(strain_meta.index)
### t-tests for each feature comparing live vs dead behaviour
ttest_path_uncorrected = stats_dir / '{}_uncorrected.csv'.format((t_test + '_' + strain))
ttest_path = stats_dir / '{}_results.csv'.format((t_test + '_' + strain))
ttest_path.parent.mkdir(exist_ok=True, parents=True)
# perform t-tests (without correction for multiple testing)
stats_t, pvals_t, reject_t = univariate_tests(X=strain_feat,
y=strain_meta[TREATMENT_COLNAME],
control=CONTROL_TREATMENT,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=None,
alpha=0.05)
# get effect sizes for comparisons
effect_sizes_t = get_effect_sizes(X=strain_feat,
y=strain_meta[TREATMENT_COLNAME],
control=CONTROL_TREATMENT,
effect_type=None,
linked_test=t_test)
# compile + save t-test results (uncorrected)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_uncorrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_uncorrected.to_csv(ttest_path_uncorrected, header=True, index=True)
# correct for multiple comparisons
pvals_t.columns = [c.split("_")[-1] for c in pvals_t.columns]
reject_t, pvals_t = _multitest_correct(pvals_t,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save t-test results (corrected)
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
ttest_corrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_corrected.to_csv(ttest_path, header=True, index=True)
# record t-test significant features (not ordered)
fset_ttest = pvals_t[np.asmatrix(reject_t)].index.unique().to_list()
#assert set(fset_ttest) == set(pvals_t.index[(pvals_t < args.pval_threshold).sum(axis=1) > 0])
print("%d significant features for %s on any %s vs %s (%s, %s, P<%.2f)" % (len(fset_ttest),
strain, TREATMENT_COLNAME, CONTROL_TREATMENT, t_test, args.fdr_method, args.pval_threshold))
if len(fset_ttest) > 0:
ttest_sigfeats_path = stats_dir / '{}_sigfeats.txt'.format((t_test + '_' + strain))
write_list_to_file(fset_ttest, ttest_sigfeats_path)
##### for LIVE bacteria: compare each strain with control #####
live_metadata = metadata[metadata['dead']==False]
live_features = features.reindex(live_metadata.index)
ttest_path_uncorrected = stats_dir / '{}_live_uncorrected.csv'.format(t_test)
ttest_path = stats_dir / '{}_live_results.csv'.format(t_test)
ttest_path.parent.mkdir(exist_ok=True, parents=True)
# perform t-tests (without correction for multiple testing)
stats_t, pvals_t, reject_t = univariate_tests(X=live_features,
y=live_metadata[STRAIN_COLNAME],
control=CONTROL_STRAIN,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=None,
alpha=0.05)
# get effect sizes for comparisons
effect_sizes_t = get_effect_sizes(X=live_features,
y=live_metadata[STRAIN_COLNAME],
control=CONTROL_STRAIN,
effect_type=None,
linked_test=t_test)
# compile + save t-test results (uncorrected)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_uncorrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_uncorrected.to_csv(ttest_path_uncorrected, header=True, index=True)
# correct for multiple comparisons
pvals_t.columns = [c.split("_")[-1] for c in pvals_t.columns]
reject_t, pvals_t = _multitest_correct(pvals_t,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save t-test results (corrected)
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
ttest_corrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_corrected.to_csv(ttest_path, header=True, index=True)
# record t-test significant features (not ordered)
fset_ttest = pvals_t[np.asmatrix(reject_t)].index.unique().to_list()
#assert set(fset_ttest) == set(pvals_t.index[(pvals_t < args.pval_threshold).sum(axis=1) > 0])
print("LIVE BACTERIA: %d significant features for any %s vs %s (%s, %s, P<%.2f)" %\
(len(fset_ttest), STRAIN_COLNAME, CONTROL_STRAIN, t_test, args.fdr_method,
args.pval_threshold))
if len(fset_ttest) > 0:
ttest_sigfeats_path = stats_dir / '{}_live_sigfeats.txt'.format(t_test)
write_list_to_file(fset_ttest, ttest_sigfeats_path)
##### for DEAD bacteria: compare each strain with control #####
dead_metadata = metadata[metadata['dead']==True]
dead_features = features.reindex(dead_metadata.index)
ttest_path_uncorrected = stats_dir / '{}_dead_uncorrected.csv'.format(t_test)
ttest_path = stats_dir / '{}_dead_results.csv'.format(t_test)
ttest_path.parent.mkdir(exist_ok=True, parents=True)
# perform t-tests (without correction for multiple testing)
stats_t, pvals_t, reject_t = univariate_tests(X=dead_features,
y=dead_metadata[STRAIN_COLNAME],
control=CONTROL_STRAIN,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=None,
alpha=0.05)
# get effect sizes for comparisons
effect_sizes_t = get_effect_sizes(X=dead_features,
y=dead_metadata[STRAIN_COLNAME],
control=CONTROL_STRAIN,
effect_type=None,
linked_test=t_test)
# compile + save t-test results (uncorrected)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_uncorrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_uncorrected.to_csv(ttest_path_uncorrected, header=True, index=True)
# correct for multiple comparisons
pvals_t.columns = [c.split("_")[-1] for c in pvals_t.columns]
reject_t, pvals_t = _multitest_correct(pvals_t,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save t-test results (corrected)
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
ttest_corrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_corrected.to_csv(ttest_path, header=True, index=True)
# record t-test significant features (not ordered)
fset_ttest = pvals_t[np.asmatrix(reject_t)].index.unique().to_list()
#assert set(fset_ttest) == set(pvals_t.index[(pvals_t < args.pval_threshold).sum(axis=1) > 0])
print("DEAD BACTERIA: %d significant features for any %s vs %s (%s, %s, P<%.2f)" %\
(len(fset_ttest), STRAIN_COLNAME, CONTROL_STRAIN, t_test, args.fdr_method,
args.pval_threshold))
if len(fset_ttest) > 0:
ttest_sigfeats_path = stats_dir / '{}_dead_sigfeats.txt'.format(t_test)
write_list_to_file(fset_ttest, ttest_sigfeats_path)
### statistics
# ANOVA to test to variation among strains
if len(metadata_df[args.strain_colname].unique()) > 2:
stats, pvals, reject = univariate_tests(
X=features_df,
y=metadata_df[args.strain_colname],
control=args.control,
test='ANOVA',
comparison_type='multiclass',
multitest_correction='fdr_by',
alpha=0.05)
# get effect sizes
effect_sizes = get_effect_sizes(X=features_df,
y=metadata_df[args.strain_colname],
control=args.control,
effect_type=None,
linked_test='ANOVA')
# compile + save results
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results = test_results.sort_values(by=['pvals'],
ascending=True) # rank pvals
anova_save_path = save_dir / 'stats' / 'ANOVA_results.csv'
anova_save_path.parent.mkdir(exist_ok=True, parents=True)
test_results.to_csv(anova_save_path, header=True, index=True)
# t-tests between each strain vs control
stats_t, pvals_t, reject_t = univariate_tests(
X=features_df,
y=metadata_df[args.strain_colname],
# for any strain
# perform ANOVA (correct for multiple comparisons) - is there variation in egg count across strains?
stats, pvals, reject = univariate_tests(X=eggs[['number_eggs_1hr']],
y=eggs['gene_name'],
test='ANOVA',
control=CONTROL_STRAIN,
comparison_type='multiclass',
multitest_correction='fdr_by',
alpha=0.05,
n_permutation_test=None) # 'all'
# get effect sizes
effect_sizes = get_effect_sizes(X=eggs[['number_eggs_1hr']],
y=eggs['gene_name'],
control=CONTROL_STRAIN,
effect_type=None,
linked_test='ANOVA')
# compile
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results = test_results.sort_values(by=['pvals'],
ascending=True) # rank pvals
# save results
anova_path = Path(SAVE_DIR) / 'ANOVA_egg_laying_variation_on_food.csv'
test_results.to_csv(anova_path, header=True, index=True)
# TODO: Chi-square tests should be performed here, not t-tests!
# t-tests: is egg count different on any food vs control?
# 1. perform chi-sq tests to see if number of eggs laid is significantly different from control
# perform ANOVA - is there variation in egg laying across antioxidants? (pooled strain data)
stats, pvals, reject = univariate_tests(X=eggs[['number_eggs_24hrs']],
y=eggs['antioxidant'],
test='ANOVA',
control=CONTROL_ANTIOXIDANT,
comparison_type='multiclass',
multitest_correction='fdr_by',
alpha=0.05,
n_permutation_test=None) # 'all'
# get effect sizes
effect_sizes = get_effect_sizes(X=eggs[['number_eggs_24hrs']],
y=eggs['antioxidant'],
control=CONTROL_ANTIOXIDANT,
effect_type=None,
linked_test='ANOVA')
# compile
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results = test_results.sort_values(by=['pvals'],
ascending=True) # rank pvals
# save results
anova_path = Path(SAVE_DIR) / 'ANOVA_egg_laying_variation_on_food.csv'
test_results.to_csv(anova_path, header=True, index=True)
# TODO: Chi-square tests should be performed here, not t-tests!
# Is there any difference in egg laying between strains, after accounting for antioxidant treatment?
def acute_rescue_stats(features,
metadata,
save_dir,
control_strain,
control_antioxidant,
control_window,
fdr_method='fdr_by',
pval_threshold=0.05):
""" Pairwise t-tests for each window comparing worm 'motion mode paused fraction' on
Keio mutants vs BW control
# One could fit a multiple linear regression model: to account for strain*antioxidant in a
# single model: Y (motion_mode) = b0 + b1*X1 (strain) + b2*X2 (antiox) + e (error)
# But this is a different type of question: we care about difference in means between
# fepD vs BW (albeit under different antioxidant treatments), and not about modelling their
# relationship, therefore individual t-tests (multiple-test-corrected) should suffice
1. For each treatment condition, t-tests comparing fepD vs BW for motion_mode
2. For fepD and BW separately, f-tests for equal variance among antioxidant treatment groups,
then ANOVA tests for significant differences between antioxidants, then individual t-tests
comparing each treatment to control
Inputs
------
features, metadata : pandas.DataFrame
window_list : list
List of windows (int) to perform statistics (separately for each window provided,
p-values are adjusted for multiple test correction)
save_dir : str
Directory to save statistics results
control_strain
control_antioxidant
fdr_method
"""
stats_dir = Path(save_dir) / "Stats" / args.fdr_method
stats_dir.mkdir(parents=True, exist_ok=True)
strain_list = [control_strain] + [s for s in set(metadata['gene_name'].unique()) if s != control_strain]
antiox_list = [control_antioxidant] + [a for a in set(metadata['antioxidant'].unique()) if
a != control_antioxidant]
window_list = [control_window] + [w for w in set(metadata['window'].unique()) if w != control_window]
# categorical variables to investigate: 'gene_name', 'antioxidant' and 'window'
print("\nInvestigating difference in fraction of worms paused between hit strain and control " +
"(for each window), in the presence/absence of antioxidants:\n")
# print mean sample size
sample_size = df_summary_stats(metadata, columns=['gene_name', 'antioxidant', 'window'])
print("Mean sample size of strain/antioxidant for each window: %d" %\
(int(sample_size['n_samples'].mean())))
# For each strain separately...
for strain in strain_list:
strain_meta = metadata[metadata['gene_name']==strain]
strain_feat = features.reindex(strain_meta.index)
# 1. Is there any variation in fraction paused wtr antioxidant treatment?
# - ANOVA on pooled window data, then pairwise t-tests for each antioxidant
print("Performing ANOVA on pooled window data for significant variation in fraction " +
"of worms paused among different antioxidant treatments for %s..." % strain)
# perform ANOVA (correct for multiple comparisons)
stats, pvals, reject = univariate_tests(X=strain_feat[[FEATURE]],
y=strain_meta['antioxidant'],
test='ANOVA',
control=control_antioxidant,
comparison_type='multiclass',
multitest_correction=fdr_method,
alpha=pval_threshold,
n_permutation_test=None) # 'all'
# get effect sizes
effect_sizes = get_effect_sizes(X=strain_feat[[FEATURE]],
y=strain_meta['antioxidant'],
control=control_antioxidant,
effect_type=None,
linked_test='ANOVA')
# compile
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats','effect_size','pvals','reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(by=['pvals'], ascending=True) # rank pvals
# save results
anova_path = Path(stats_dir) / 'ANOVA_{}_variation_across_antioxidants.csv'.format(strain)
test_results.to_csv(anova_path, header=True, index=True)
print("Performing t-tests comparing each antioxidant treatment to None (pooled window data)")
stats_t, pvals_t, reject_t = univariate_tests(X=strain_feat[[FEATURE]],
y=strain_meta['antioxidant'],
test='t-test',
control=control_antioxidant,
comparison_type='binary_each_group',
multitest_correction=fdr_method,
alpha=pval_threshold)
effect_sizes_t = get_effect_sizes(X=strain_feat[[FEATURE]],
y=strain_meta['antioxidant'],
control=control_antioxidant,
effect_type=None,
linked_test='t-test')
# compile + save t-test results
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_results = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_save_path = stats_dir / 't-test_{}_antioxidant_results.csv'.format(strain)
ttest_save_path.parent.mkdir(exist_ok=True, parents=True)
ttest_results.to_csv(ttest_save_path, header=True, index=True)
# 2. Is there any variation in fraction paused wrt window (time) across the videos?
# - ANOVA on pooled antioxidant data, then pairwise for each window
print("Performing ANOVA on pooled antioxidant data for significant variation in fraction " +
"of worms paused across (bluelight) window summaries for %s..." % strain)
# perform ANOVA (correct for multiple comparisons)
stats, pvals, reject = univariate_tests(X=strain_feat[[FEATURE]],
y=strain_meta['window'],
test='ANOVA',
control=control_window,
comparison_type='multiclass',
multitest_correction=fdr_method,
alpha=pval_threshold,
n_permutation_test=None)
# get effect sizes
effect_sizes = get_effect_sizes(X=strain_feat[[FEATURE]],
y=strain_meta['window'],
control=control_window,
effect_type=None,
linked_test='ANOVA')
# compile
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats','effect_size','pvals','reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(by=['pvals'], ascending=True) # rank pvals
# save results
anova_path = Path(stats_dir) / 'ANOVA_{}_variation_across_windows.csv'.format(strain)
test_results.to_csv(anova_path, header=True, index=True)
print("Performing t-tests comparing each window with the first (pooled antioxidant data)")
stats_t, pvals_t, reject_t = univariate_tests(X=strain_feat[[FEATURE]],
y=strain_meta['window'],
test='t-test',
control=control_window,
comparison_type='binary_each_group',
multitest_correction=fdr_method,
alpha=pval_threshold)
effect_sizes_t = get_effect_sizes(X=strain_feat[[FEATURE]],
y=strain_meta['window'],
control=control_window,
effect_type=None,
linked_test='t-test')
# compile + save t-test results
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_results = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_save_path = stats_dir / 't-test_{}_window_results.csv'.format(strain)
ttest_save_path.parent.mkdir(exist_ok=True, parents=True)
ttest_results.to_csv(ttest_save_path, header=True, index=True)
# Pairwise t-tests - is there a difference between strain vs control?
control_meta = metadata[metadata['gene_name']==control_strain]
control_feat = features.reindex(control_meta.index)
control_df = control_meta.join(control_feat[[FEATURE]])
for strain in strain_list[1:]: # skip control_strain at first index postion
strain_meta = metadata[metadata['gene_name']==strain]
strain_feat = features.reindex(strain_meta.index)
strain_df = strain_meta.join(strain_feat[[FEATURE]])
# 3. Is there a difference between strain vs control at any window?
print("\nPairwise t-tests for each window (pooled antioxidants) comparing fraction of " +
"worms paused on %s vs control:" % strain)
stats, pvals, reject = pairwise_ttest(control_df,
strain_df,
feature_list=[FEATURE],
group_by='window',
fdr_method=fdr_method,
fdr=0.05)
# compile table of results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
test_results = pd.concat([stats, pvals, reject], axis=1)
# save results
ttest_strain_path = stats_dir / 'pairwise_ttests' / 'window' /\
'{}_window_results.csv'.format(strain)
ttest_strain_path.parent.mkdir(parents=True, exist_ok=True)
test_results.to_csv(ttest_strain_path, header=True, index=True)
# for each antioxidant treatment condition...
for antiox in antiox_list:
print("Pairwise t-tests for each window comparing fraction of " +
"worms paused on %s vs control with '%s'" % (strain, antiox))
antiox_control_df = control_df[control_df['antioxidant']==antiox]
antiox_strain_df = strain_df[strain_df['antioxidant']==antiox]
stats, pvals, reject = pairwise_ttest(antiox_control_df,
antiox_strain_df,
feature_list=[FEATURE],
group_by='window',
fdr_method=fdr_method,
fdr=0.05)
# compile table of results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
test_results = pd.concat([stats, pvals, reject], axis=1)
# save results
ttest_strain_path = stats_dir / 'pairwise_ttests' / 'window' /\
'{0}_{1}_window_results.csv'.format(strain, antiox)
ttest_strain_path.parent.mkdir(parents=True, exist_ok=True)
test_results.to_csv(ttest_strain_path, header=True, index=True)
# 4. Is there a difference between strain vs control for any antioxidant?
print("\nPairwise t-tests for each antioxidant (pooled windows) comparing fraction of " +
"worms paused on %s vs control:" % strain)
stats, pvals, reject = pairwise_ttest(control_df,
strain_df,
feature_list=[FEATURE],
group_by='antioxidant',
fdr_method=fdr_method,
fdr=0.05)
# compile table of results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
test_results = pd.concat([stats, pvals, reject], axis=1)
# save results
ttest_strain_path = stats_dir / 'pairwise_ttests' / 'antioxidant' /\
'{}_antioxidant_results.csv'.format(strain)
ttest_strain_path.parent.mkdir(parents=True, exist_ok=True)
test_results.to_csv(ttest_strain_path, header=True, index=True)
# For each window...
for window in window_list:
print("Pairwise t-tests for each antioxidant comparing fraction of " +
"worms paused on %s vs control at window %d" % (strain, window))
window_control_df = control_df[control_df['window']==window]
window_strain_df = strain_df[strain_df['window']==window]
stats, pvals, reject = pairwise_ttest(window_control_df,
window_strain_df,
feature_list=[FEATURE],
group_by='antioxidant',
fdr_method=fdr_method,
fdr=0.05)
# compile table of results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
test_results = pd.concat([stats, pvals, reject], axis=1)
# save results
ttest_strain_path = stats_dir / 'pairwise_ttests' / 'antioxidant' /\
'{0}_window{1}_antioxidant_results.csv'.format(strain, window)
ttest_strain_path.parent.mkdir(parents=True, exist_ok=True)
test_results.to_csv(ttest_strain_path, header=True, index=True)
return
def antioxidant_stats(features, metadata, args):
""" Perform statistical analyses on Keio antioxidant rescue experiment results:
- ANOVA tests for significant feature variation between strains (for each antioxidant treatment in turn)
- ANOVA tests for significant feature variation in antioxidant treatment (for each strain in turn)
- t-tests for each feature comparing each strain vs control for paired antioxidant treatment conditions
- t-tests for each feature comparing each strain antioxidant treatment to negative control (no antioxidant)
Inputs
------
features, metadata : pd.DataFrame
Clean feature summaries and accompanying metadata
args : Object
Python object with the following attributes:
- drop_size_features : bool
- norm_features_only : bool
- percentile_to_use : str
- remove_outliers : bool
- control_dict : dict
- n_top_feats : int
- tierpsy_top_feats_dir (if n_top_feats) : str
- test : str
- f_test : bool
- pval_threshold : float
- fdr_method : str
- n_sig_features : int
"""
# categorical variables to investigate: 'gene_name' and 'antioxidant'
print(
"\nInvestigating variation in worm behaviour on hit strains treated with different antioxidants"
)
# assert there will be no errors due to case-sensitivity
assert len(metadata[STRAIN_COLNAME].unique()) == len(
metadata[STRAIN_COLNAME].str.upper().unique())
assert len(metadata[TREATMENT_COLNAME].unique()) == len(
metadata[TREATMENT_COLNAME].str.upper().unique())
assert not features.isna().any().any()
strain_list = list(metadata[STRAIN_COLNAME].unique())
antioxidant_list = list(metadata[TREATMENT_COLNAME].unique())
assert CONTROL_STRAIN in strain_list and CONTROL_TREATMENT in antioxidant_list
# print mean sample size
sample_size = df_summary_stats(metadata,
columns=[STRAIN_COLNAME, TREATMENT_COLNAME])
print("Mean sample size of %s: %d" %
(STRAIN_COLNAME, int(sample_size['n_samples'].mean())))
# construct save paths (args.save_dir / topfeats? etc)
save_dir = get_save_dir(args)
stats_dir = save_dir / "Stats" / args.fdr_method
### For each antioxidant treatment in turn...
for antiox in antioxidant_list:
print("\n%s" % antiox)
meta_antiox = metadata[metadata[TREATMENT_COLNAME] == antiox]
feat_antiox = features.reindex(meta_antiox.index)
### ANOVA tests for significant variation between strains
# make path to save ANOVA results
test_path_unncorrected = stats_dir / '{}_uncorrected.csv'.format(
(args.test + '_' + antiox))
test_path = stats_dir / '{}_results.csv'.format(
(args.test + '_' + antiox))
test_path.parent.mkdir(exist_ok=True, parents=True)
if len(meta_antiox[STRAIN_COLNAME].unique()) > 2:
# perform ANOVA + record results before & after correcting for multiple comparisons
stats, pvals, reject = univariate_tests(
X=feat_antiox,
y=meta_antiox[STRAIN_COLNAME],
test=args.test,
control=CONTROL_STRAIN,
comparison_type='multiclass',
multitest_correction=None, # uncorrected
alpha=args.pval_threshold,
n_permutation_test=None) # 'all'
# get effect sizes
effect_sizes = get_effect_sizes(X=feat_antiox,
y=meta_antiox[STRAIN_COLNAME],
control=CONTROL_STRAIN,
effect_type=None,
linked_test=args.test)
# compile + save results (uncorrected)
test_results = pd.concat([stats, effect_sizes, pvals, reject],
axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(
by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path_unncorrected,
header=True,
index=True)
# correct for multiple comparisons
reject_corrected, pvals_corrected = _multitest_correct(
pvals,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save results (corrected)
test_results = pd.concat(
[stats, effect_sizes, pvals_corrected, reject_corrected],
axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(
by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path, header=True, index=True)
print(
"%s differences in '%s' across strains on %s (%s, P<%.2f, %s)"
% (("SIGNIFICANT" if reject_corrected.loc[FEATURE, args.test]
else "No significant"), FEATURE, antiox, args.test,
args.pval_threshold, args.fdr_method))
else:
print("\nWARNING: Not enough %s groups for %s (n=%d)" %\
(STRAIN_COLNAME, args.test, len(strain_list)))
### t-tests comparing each strain vs control for each antioxidant treatment conditions
if len(meta_antiox[STRAIN_COLNAME].unique()) == 2 or (
len(meta_antiox[STRAIN_COLNAME].unique()) > 2
and reject_corrected.loc[FEATURE, args.test]):
# t-test to use
t_test = 't-test' if args.test == 'ANOVA' else 'Mann-Whitney' # aka. Wilcoxon rank-sum
ttest_path_uncorrected = stats_dir / '{}_uncorrected.csv'.format(
(t_test + '_' + antiox))
ttest_path = stats_dir / '{}_results.csv'.format(
(t_test + '_' + antiox))
ttest_path.parent.mkdir(exist_ok=True, parents=True)
# perform t-tests (without correction for multiple testing)
stats_t, pvals_t, reject_t = univariate_tests(
X=feat_antiox,
y=meta_antiox[STRAIN_COLNAME],
control=CONTROL_STRAIN,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=None,
alpha=0.05)
# get effect sizes for comparisons
effect_sizes_t = get_effect_sizes(X=feat_antiox,
y=meta_antiox[STRAIN_COLNAME],
control=CONTROL_STRAIN,
effect_type=None,
linked_test=t_test)
# compile + save t-test results (uncorrected)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = [
'effect_size_' + str(c) for c in effect_sizes_t.columns
]
ttest_uncorrected = pd.concat(
[stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_uncorrected.to_csv(ttest_path_uncorrected,
header=True,
index=True)
# correct for multiple comparisons
pvals_t.columns = [c.split("_")[-1] for c in pvals_t.columns]
reject_t, pvals_t = _multitest_correct(
pvals_t,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save t-test results (corrected)
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
ttest_corrected = pd.concat(
[stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_corrected.to_csv(ttest_path, header=True, index=True)
nsig = reject_t.loc[FEATURE].sum()
print("%d %ss differ from %s in '%s' on %s (%s, P<%.2f, %s)" %
(nsig, STRAIN_COLNAME, CONTROL_STRAIN, FEATURE, antiox,
t_test, args.pval_threshold, args.fdr_method))
### For each strain in turn...
for strain in strain_list:
print("\n%s" % strain)
meta_strain = metadata[metadata[STRAIN_COLNAME] == strain]
feat_strain = features.reindex(meta_strain.index)
### ANOVA tests for significant feature variation in antioxidant treatment
# make path to save ANOVA results
test_path_unncorrected = stats_dir / '{}_uncorrected.csv'.format(
(args.test + '_' + strain))
test_path = stats_dir / '{}_results.csv'.format(
(args.test + '_' + strain))
test_path.parent.mkdir(exist_ok=True, parents=True)
if len(meta_strain[TREATMENT_COLNAME].unique()) > 2:
# perform ANOVA + record results before & after correcting for multiple comparisons
stats, pvals, reject = univariate_tests(
X=feat_strain,
y=meta_strain[TREATMENT_COLNAME],
test=args.test,
control=CONTROL_TREATMENT,
comparison_type='multiclass',
multitest_correction=None, # uncorrected
alpha=args.pval_threshold,
n_permutation_test=None) # 'all'
# get effect sizes
effect_sizes = get_effect_sizes(X=feat_strain,
y=meta_strain[TREATMENT_COLNAME],
control=CONTROL_TREATMENT,
effect_type=None,
linked_test=args.test)
# compile + save results (uncorrected)
test_results = pd.concat([stats, effect_sizes, pvals, reject],
axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(
by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path_unncorrected,
header=True,
index=True)
# correct for multiple comparisons
reject_corrected, pvals_corrected = _multitest_correct(
pvals,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save results (corrected)
test_results = pd.concat(
[stats, effect_sizes, pvals_corrected, reject_corrected],
axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(
by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path, header=True, index=True)
print("%s differences in '%s' across %ss for %s (%s, P<%.2f, %s)" %
(("SIGNIFICANT" if reject_corrected.loc[FEATURE, args.test]
else "No"), FEATURE, TREATMENT_COLNAME, strain, args.test,
args.pval_threshold, args.fdr_method))
else:
print("\nWARNING: Not enough %s groups for %s (n=%d)" %\
(TREATMENT_COLNAME, args.test, len(antioxidant_list)))
### t-tests comparing each antioxidant treatment to no antioxidant for each strain
if len(meta_strain[TREATMENT_COLNAME].unique()) == 2 or (
len(meta_strain[TREATMENT_COLNAME].unique()) > 2
and reject_corrected.loc[FEATURE, args.test]):
# t-test to use
t_test = 't-test' if args.test == 'ANOVA' else 'Mann-Whitney' # aka. Wilcoxon rank-sum
ttest_path_uncorrected = stats_dir / '{}_uncorrected.csv'.format(
(t_test + '_' + strain))
ttest_path = stats_dir / '{}_results.csv'.format(
(t_test + '_' + strain))
ttest_path.parent.mkdir(exist_ok=True, parents=True)
# perform t-tests (without correction for multiple testing)
stats_t, pvals_t, reject_t = univariate_tests(
X=feat_strain,
y=meta_strain[TREATMENT_COLNAME],
control=CONTROL_TREATMENT,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=None,
alpha=0.05)
# get effect sizes for comparisons
effect_sizes_t = get_effect_sizes(X=feat_strain,
y=meta_strain[TREATMENT_COLNAME],
control=CONTROL_TREATMENT,
effect_type=None,
linked_test=t_test)
# compile + save t-test results (uncorrected)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = [
'effect_size_' + str(c) for c in effect_sizes_t.columns
]
ttest_uncorrected = pd.concat(
[stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_uncorrected.to_csv(ttest_path_uncorrected,
header=True,
index=True)
# correct for multiple comparisons
pvals_t.columns = [c.split("_")[-1] for c in pvals_t.columns]
reject_t, pvals_t = _multitest_correct(
pvals_t,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save t-test results (corrected)
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
ttest_corrected = pd.concat(
[stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_corrected.to_csv(ttest_path, header=True, index=True)
nsig = reject_t.loc[FEATURE].sum()
print("%d %ss differ from %s in '%s' for %s (%s, P<%.2f, %s)" %
(nsig, TREATMENT_COLNAME, CONTROL_TREATMENT, FEATURE, strain,
t_test, args.pval_threshold, args.fdr_method))
### Pairwise t-tests comparing strain vs control behaviour on each antioxidant
print("\nPerforming pairwise t-tests:")
# subset for control data
control_strain_meta = metadata[metadata[STRAIN_COLNAME] == CONTROL_STRAIN]
control_strain_feat = features.reindex(control_strain_meta.index)
control_df = control_strain_meta.join(control_strain_feat)
for strain in strain_list:
if strain == CONTROL_STRAIN:
continue
# subset for strain data
strain_meta = metadata[metadata[STRAIN_COLNAME] == strain]
strain_feat = features.reindex(strain_meta.index)
strain_df = strain_meta.join(strain_feat)
# perform pairwise t-tests comparing strain with control for each antioxidant treatment
stats, pvals, reject = pairwise_ttest(control_df,
strain_df,
feature_list=[FEATURE],
group_by=TREATMENT_COLNAME,
fdr_method=args.fdr_method,
fdr=args.pval_threshold)
# compile table of results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
test_results = pd.concat([stats, pvals, reject], axis=1)
# save results
ttest_strain_path = stats_dir / 'pairwise_ttests' / '{}_results.csv'.format(
strain + "_vs_" + CONTROL_STRAIN)
ttest_strain_path.parent.mkdir(parents=True, exist_ok=True)
test_results.to_csv(ttest_strain_path, header=True, index=True)
for antiox in antioxidant_list:
print("%s difference in '%s' between %s vs %s on %s (paired t-test, P=%.3f, %s)" %\
(("SIGNIFICANT" if reject.loc[FEATURE, 'reject_{}'.format(antiox)] else "No"),
FEATURE, strain, CONTROL_STRAIN, antiox, pvals.loc[FEATURE, 'pvals_{}'.format(antiox)],
args.fdr_method))
def keio_stats(features, metadata, args):
""" Perform statistical analyses on Keio screen results:
- ANOVA tests for significant between strain variation among all strains for each feature
- t-tests for significant differences between each strain and control for each feature
- k-significant feature selection for agreement with ANOVA significant feature set
Inputs
------
features, metadata : pd.DataFrame
Clean feature summaries and accompanying metadata
args : Object
Python object with the following attributes:
- drop_size_features : bool
- norm_features_only : bool
- percentile_to_use : str
- remove_outliers : bool
- omit_strains : list
- grouping_variable : str
- control_dict : dict
- collapse_control : bool
- n_top_feats : int
- tierpsy_top_feats_dir (if n_top_feats) : str
- test : str
- f_test : bool
- pval_threshold : float
- fdr_method : str
- n_sig_features : int
"""
# categorical variable to investigate, eg.'gene_name'
grouping_var = args.grouping_variable
print("\nInvestigating '%s' variation" % grouping_var)
# assert there will be no errors duee to case-sensitivity
assert len(metadata[grouping_var].unique()) == len(metadata[grouping_var].str.upper().unique())
# Subset results (rows) to omit selected strains
if args.omit_strains is not None:
features, metadata = subset_results(features, metadata, grouping_var, args.omit_strains)
# Load Tierpsy Top feature set + subset (columns) for top feats only
if args.n_top_feats is not None:
top_feats_path = Path(args.tierpsy_top_feats_dir) / "tierpsy_{}.csv".format(str(args.n_top_feats))
topfeats = load_topfeats(top_feats_path, add_bluelight=args.align_bluelight,
remove_path_curvature=True, header=None)
# Drop features that are not in results
top_feats_list = [feat for feat in list(topfeats) if feat in features.columns]
features = features[top_feats_list]
assert not features.isna().any().any()
strain_list = list(metadata[grouping_var].unique())
control = args.control_dict[grouping_var] # control strain to use
assert control in strain_list
if args.collapse_control:
print("Collapsing control data (mean of each day)")
features, metadata = average_plate_control_data(features,
metadata,
control=control,
grouping_var=grouping_var,
plate_var='imaging_plate_id')
_ = df_summary_stats(metadata) # summary df # TODO: plot from?
# Record mean sample size per group
mean_sample_size = int(np.round(metadata.join(features).groupby([grouping_var],
as_index=False).size().mean()))
print("Mean sample size: %d" % mean_sample_size)
# construct save paths (args.save_dir / topfeats? etc)
save_dir = get_save_dir(args)
stats_dir = save_dir / grouping_var / "Stats" / args.fdr_method
plot_dir = save_dir / grouping_var / "Plots" / args.fdr_method
#%% F-test for equal variances
# Compare variance in samples with control (and correct for multiple comparisons)
# Sample size matters in that unequal variances don't pose a problem for a t-test with
# equal sample sizes. So as long as your sample sizes are equal, you don't have to worry about
# homogeneity of variances. If they are not equal, perform F-tests first to see if variance is
# equal before doing a t-test
if args.f_test:
levene_stats_path = stats_dir / 'levene_results.csv'
levene_stats = levene_f_test(features, metadata, grouping_var,
p_value_threshold=args.pval_threshold,
multitest_method=args.fdr_method,
saveto=levene_stats_path,
del_if_exists=False)
# if p < 0.05 then variances are not equal, and sample size matters
prop_eqvar = (levene_stats['pval'] > args.pval_threshold).sum() / len(levene_stats['pval'])
print("Percentage equal variance %.1f%%" % (prop_eqvar * 100))
#%% ANOVA / Kruskal-Wallis tests for significantly different features across groups
test_path_unncorrected = stats_dir / '{}_results_uncorrected.csv'.format(args.test)
test_path = stats_dir / '{}_results.csv'.format(args.test)
if not (test_path.exists() and test_path_unncorrected.exists()):
test_path.parent.mkdir(exist_ok=True, parents=True)
if (args.test == "ANOVA" or args.test == "Kruskal"):
if len(strain_list) > 2:
# perform ANOVA + record results before & after correcting for multiple comparisons
stats, pvals, reject = univariate_tests(X=features,
y=metadata[grouping_var],
control=control,
test=args.test,
comparison_type='multiclass',
multitest_correction=None, # uncorrected
alpha=args.pval_threshold,
n_permutation_test='all')
# get effect sizes
effect_sizes = get_effect_sizes(X=features,
y=metadata[grouping_var],
control=control,
effect_type=None,
linked_test=args.test)
# compile + save results (uncorrected)
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats','effect_size','pvals','reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path_unncorrected, header=True, index=True)
# correct for multiple comparisons
reject_corrected, pvals_corrected = _multitest_correct(pvals,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save results (corrected)
test_results = pd.concat([stats, effect_sizes, pvals_corrected, reject_corrected], axis=1)
test_results.columns = ['stats','effect_size','pvals','reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(by=['pvals'], ascending=True) # rank pvals
test_results.to_csv(test_path, header=True, index=True)
# use reject mask to find significant feature set
fset = pvals.loc[reject[args.test]].sort_values(by=args.test, ascending=True).index.to_list()
#assert set(fset) == set(anova_corrected['pvals'].index[np.where(anova_corrected['pvals'] <
#args.pval_threshold)[0]])
if len(fset) > 0:
print("%d significant features found by %s for '%s' (P<%.2f, %s)" % (len(fset),
args.test, grouping_var, args.pval_threshold, args.fdr_method))
anova_sigfeats_path = stats_dir / '{}_sigfeats.txt'.format(args.test)
write_list_to_file(fset, anova_sigfeats_path)
else:
fset = []
print("\nWARNING: Not enough groups for %s for '%s' (n=%d groups)" %\
(args.test, grouping_var, len(strain_list)))
#%% Linear Mixed Models (LMMs), accounting for day-to-day variation
# NB: Ideally report: parameter | beta | lower-95 | upper-95 | random effect (SD)
elif args.test == 'LMM':
with warnings.catch_warnings():
# Filter warnings as parameter is often on the boundary
warnings.filterwarnings("ignore")
#warnings.simplefilter("ignore", ConvergenceWarning)
(signif_effect, low_effect, error, mask, pvals
) = compounds_with_low_effect_univariate(feat=features,
drug_name=metadata[grouping_var],
drug_dose=None,
random_effect=metadata[args.lmm_random_effect],
control=control,
test=args.test,
comparison_type='multiclass',
multitest_method=args.fdr_method)
assert len(error) == 0
# save pvals
pvals.to_csv(test_path_unncorrected, header=True, index=True)
# save significant features -- if any strain significant for any feature
fset = pvals.columns[(pvals < args.pval_threshold).any()].to_list()
if len(fset) > 0:
lmm_sigfeats_path = stats_dir / '{}_sigfeats.txt'.format(args.test)
write_list_to_file(fset, lmm_sigfeats_path)
# save significant effect strains
if len(signif_effect) > 0:
print(("%d significant features found (%d significant %ss vs %s control, "\
% (len(fset), len(signif_effect), grouping_var.replace('_',' '),
control) if len(signif_effect) > 0 else\
"No significant differences found between %s "\
% grouping_var.replace('_',' '))
+ "after accounting for %s variation, %s, P<%.2f, %s)"\
% (args.lmm_random_effect.split('_yyyymmdd')[0], args.test,
args.pval_threshold, args.fdr_method))
signif_effect_path = stats_dir / '{}_signif_effect_strains.txt'.format(args.test)
write_list_to_file(signif_effect, signif_effect_path)
else:
raise IOError("Test '{}' not recognised".format(args.test))
#%% t-tests / Mann-Whitney tests
# t-test to use
t_test = 't-test' if args.test == 'ANOVA' else 'Mann-Whitney' # aka. Wilcoxon rank-sum
ttest_path_uncorrected = stats_dir / '{}_results_uncorrected.csv'.format(t_test)
ttest_path = stats_dir / '{}_results.csv'.format(t_test)
if not (ttest_path_uncorrected.exists() and ttest_path.exists()):
ttest_path.parent.mkdir(exist_ok=True, parents=True)
if len(fset) > 0 or len(strain_list) == 2:
# perform t-tests (without correction for multiple testing)
stats_t, pvals_t, reject_t = univariate_tests(X=features,
y=metadata[grouping_var],
control=control,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=None,
alpha=0.05)
# get effect sizes for comparisons
effect_sizes_t = get_effect_sizes(X=features,
y=metadata[grouping_var],
control=control,
effect_type=None,
linked_test=t_test)
# compile + save t-test results (uncorrected)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_uncorrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_uncorrected.to_csv(ttest_path_uncorrected, header=True, index=True)
# correct for multiple comparisons
pvals_t.columns = [c.split("_")[-1] for c in pvals_t.columns]
reject_t, pvals_t = _multitest_correct(pvals_t,
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# compile + save t-test results (corrected)
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
ttest_corrected = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
ttest_corrected.to_csv(ttest_path, header=True, index=True)
# record t-test significant features (not ordered)
fset_ttest = pvals_t[np.asmatrix(reject_t)].index.unique().to_list()
#assert set(fset_ttest) == set(pvals_t.index[(pvals_t < args.pval_threshold).sum(axis=1) > 0])
print("%d significant features found for any %s vs %s (%s, P<%.2f)" %\
(len(fset_ttest), grouping_var, control, t_test, args.pval_threshold))
if len(fset_ttest) > 0:
ttest_sigfeats_path = stats_dir / '{}_sigfeats.txt'.format(t_test)
write_list_to_file(fset_ttest, ttest_sigfeats_path)
#%% K significant features
ksig_uncorrected_path = stats_dir / 'k_significant_features_uncorrected.csv'
ksig_corrected_path = stats_dir / 'k_significant_features.csv'
if not (ksig_uncorrected_path.exists() and ksig_corrected_path.exists()):
ksig_corrected_path.parent.mkdir(exist_ok=True, parents=True)
fset_ksig, (scores, pvalues_ksig), support = k_significant_feat(feat=features,
y_class=metadata[grouping_var],
k=len(fset),
score_func='f_classif',
scale=None,
feat_names=None,
plot=False,
k_to_plot=None,
close_after_plotting=True,
saveto=None, #k_sigfeat_dir
figsize=None,
title=None,
xlabel=None)
# compile + save k-significant features (uncorrected)
ksig_table = pd.concat([pd.Series(scores), pd.Series(pvalues_ksig)], axis=1)
ksig_table.columns = ['scores','pvals']
ksig_table.index = fset_ksig
ksig_table.to_csv(ksig_uncorrected_path, header=True, index=True)
# Correct for multiple comparisons
_, ksig_table['pvals'] = _multitest_correct(ksig_table['pvals'],
multitest_method=args.fdr_method,
fdr=args.pval_threshold)
# save k-significant features (corrected)
ksig_table.to_csv(ksig_corrected_path, header=True, index=True)
#%% mRMR feature selection: minimum Redunduncy, Maximum Relevance #####
mrmr_dir = plot_dir / 'mrmr'
mrmr_dir.mkdir(exist_ok=True, parents=True)
mrmr_results_path = mrmr_dir / "mrmr_results.csv"
if not mrmr_results_path.exists():
estimator = Pipeline([('scaler', StandardScaler()), ('estimator', LogisticRegression())])
y = metadata[grouping_var].values
(mrmr_feat_set,
mrmr_scores,
mrmr_support) = mRMR_feature_selection(features, y_class=y, k=10,
redundancy_func='pearson_corr',
relevance_func='kruskal',
n_bins=10, mrmr_criterion='MID',
plot=True, k_to_plot=5,
close_after_plotting=True,
saveto=mrmr_dir, figsize=None)
# save results
mrmr_table = pd.concat([pd.Series(mrmr_feat_set), pd.Series(mrmr_scores)], axis=1)
mrmr_table.columns = ['feature','score']
mrmr_table.to_csv(mrmr_results_path, header=True, index=False)
n_cv = 5
cv_scores_mrmr = cross_val_score(estimator, features[mrmr_feat_set], y, cv=n_cv)
cv_scores_mrmr = pd.DataFrame(cv_scores_mrmr, columns=['cv_score'])
cv_scores_mrmr.to_csv(mrmr_dir / "cv_scores.csv", header=True, index=False)
print('MRMR CV Score: %f (n=%d)' % (np.mean(cv_scores_mrmr), n_cv))
else:
# load mrmr results
mrmr_table = pd.read_csv(mrmr_results_path)
mrmr_feat_set = mrmr_table['feature'].to_list()
print("\nTop %d features found by MRMR:" % len(mrmr_feat_set))
for feat in mrmr_feat_set:
print(feat)
def single_feature_window_stats(metadata,
features,
group_by,
control,
save_dir,
windows=None,
feat='motion_mode_paused_fraction',
pvalue_threshold=0.05,
fdr_method='fdr_by'):
""" Pairwise t-tests for each window comparing a feature of worm behaviour on mutant strains
vs control
Parameters
----------
metadata : pandas.DataFrame
features : pandas.DataFrame
Dataframe of compiled window summaries
group_by : str
Column name of variable containing control and other groups to compare, eg. 'gene_name'
control : str
Name of control group in 'group_by' column in metadata
save_dir : str
Path to directory to save results files
windows : list
List of window numbers at which to compare strains (corrected for multiple testing)
feat : str
Feature to test
pvalue_threshold : float
P-value significance threshold
fdr_method : str
Multiple testing correction method to use
"""
import pandas as pd
from pathlib import Path
from statistical_testing.stats_helper import pairwise_ttest
from statistical_testing.perform_keio_stats import df_summary_stats
from visualisation.plotting_helper import sig_asterix
from write_data.write import write_list_to_file
from tierpsytools.analysis.statistical_tests import univariate_tests, get_effect_sizes
# categorical variables to investigate: 'gene_name' and 'window'
print(
"\nInvestigating variation in fraction of worms paused between hit strains and control "
+ "(for each window)")
# check there will be no errors due to case-sensitivity
assert len(metadata[group_by].unique()) == len(
metadata[group_by].str.upper().unique())
# subset for list of windows
if windows is None:
windows = sorted(metadata['window'].unique())
else:
assert all(w in sorted(metadata['window'].unique()) for w in windows)
metadata = metadata[metadata['window'].isin(windows)]
features = features[[feat]].reindex(metadata.index)
# print mean sample size
sample_size = df_summary_stats(metadata, columns=[group_by, 'window'])
print("Mean sample size of %s/window: %d" %
(group_by, int(sample_size['n_samples'].mean())))
control_meta = metadata[metadata[group_by] == control]
control_feat = features.reindex(control_meta.index)
control_df = control_meta.join(control_feat)
n = len(metadata[group_by].unique())
strain_list = list(
[s for s in metadata[group_by].unique() if s != control])
fset = []
if n > 2:
# Perform ANOVA - is there variation among strains at each window?
anova_path = Path(
save_dir) / 'ANOVA' / 'ANOVA_{}window_results.csv'.format(
len(windows))
anova_path.parent.mkdir(parents=True, exist_ok=True)
stats, pvals, reject = univariate_tests(
X=features,
y=metadata[group_by],
control=control,
test='ANOVA',
comparison_type='multiclass',
multitest_correction=fdr_method,
alpha=pvalue_threshold,
n_permutation_test=None)
# get effect sizes
effect_sizes = get_effect_sizes(X=features,
y=metadata[group_by],
control=control,
effect_type=None,
linked_test='ANOVA')
# compile + save results
test_results = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
test_results.columns = ['stats', 'effect_size', 'pvals', 'reject']
test_results['significance'] = sig_asterix(test_results['pvals'])
test_results = test_results.sort_values(
by=['pvals'], ascending=True) # rank by p-value
test_results.to_csv(anova_path, header=True, index=True)
# use reject mask to find significant feature set
fset = pvals.loc[reject['ANOVA']].sort_values(
by='ANOVA', ascending=True).index.to_list()
if len(fset) > 0:
print("%d significant features found by ANOVA for '%s' (P<%.2f, %s)" %\
(len(fset), group_by, pvalue_threshold, fdr_method))
anova_sigfeats_path = anova_path.parent / 'ANOVA_sigfeats.txt'
write_list_to_file(fset, anova_sigfeats_path)
if n == 2 or len(fset) > 0:
# pairwise t-tests
for strain in strain_list:
print(
"\nPairwise t-tests for each window comparing fraction of worms paused "
+ "on %s vs control" % strain)
ttest_strain_path = Path(save_dir) / 'pairwise_ttests' /\
'{}_window_results.csv'.format(strain)
ttest_strain_path.parent.mkdir(parents=True, exist_ok=True)
strain_meta = metadata[metadata[group_by] == strain]
strain_feat = features.reindex(strain_meta.index)
strain_df = strain_meta.join(strain_feat[[feat]])
stats, pvals, reject = pairwise_ttest(control_df,
strain_df,
feature_list=[feat],
group_by='window',
fdr_method=fdr_method,
fdr=pvalue_threshold)
# compile table of results
stats.columns = ['stats_' + str(c) for c in stats.columns]
pvals.columns = ['pvals_' + str(c) for c in pvals.columns]
reject.columns = ['reject_' + str(c) for c in reject.columns]
test_results = pd.concat([stats, pvals, reject], axis=1)
# save results
test_results.to_csv(ttest_strain_path, header=True, index=True)
for window in windows:
print("%s difference in '%s' between %s vs %s in window %s (t-test, P=%.3f, %s)" %\
(("SIGNIFICANT" if reject.loc[feat, 'reject_{}'.format(window)] else "No"),
feat, strain, control, window, pvals.loc[feat, 'pvals_{}'.format(window)],
fdr_method))
return
def compounds_univariate_effect_sizes(feat,
drug_name,
drug_dose=None,
control='DMSO',
test='ANOVA',
comparison_type='multiclass',
ignore_names=['NoCompound'],
n_jobs=-1):
"""
Estimates the effect size of drugs at different doses compared to control.
Parameters
----------
feat : dataframe
feature dataframe, shape=(n_samples, n_features)
drug_name : array-like, shape=(n_samples)
defines the type of drug in each sample
drug_dose : array-like or None, shape=(n_samples)
defines the drug dose in each sample.
If None, it is assumed that each drug was tested at a single dose.
control : str
the name of the control samples in the drug_name array
test : str, options: ['ANOVA', 't-test', 'Kruskal_Wallis', 'Wilkoxon_Rank_Sum']
The type of statistical comparison that will define the type of effect size.
comparison_type : str, options: ['multiclass', 'binary_each_dose']
defines the groups seen in the statistical test.
- If 'multiclass', then one comparison is made considering the controls
and each drug dose as separate groups.
- If 'binary_each_dose', then separate tests are performed for each
dose in every feature. Each test compares one dose to the controls.
If any of the tests reaches the significance thresshold (after
correction for multiple comparisons), then the feature is
considered significant.
* When only one dose was tested per compound, then this parameter can take any value.
ignore_names : list or None, optional
list of names from the drug_name array to ignore in the comparisons
(in addition to the control)
n_jobs: int
Number of jobs for parallel processing.
Return
------
effect : dataframe
a dataframe with all the effect sizes per drug
"""
from tierpsytools.analysis.statistical_tests import get_effect_sizes
if drug_dose is None:
drug_dose = np.ones(drug_name.shape)
drug_dose[drug_name == control] = 0
# get the dose entry for the control
control_dose = np.unique(drug_dose[drug_name == control])
if control_dose.shape[0] > 1:
raise ValueError('The dose assinged to the control data is not ' +
'unique.')
control_dose = control_dose[0]
# Ignore the control and any names defined by user
if ignore_names is None:
ignore_names = []
ignore_names.append(control)
# Get the list of drug names to test
drug_names = np.array(
[drug for drug in np.unique(drug_name) if drug not in ignore_names])
# Initialize list to store effect_sizes
effect = {}
# Loop over drugs to test
for idrug, drug in enumerate(drug_names):
print('Getting effect sizes for compound {}...'.format(drug))
# get mask for the samples of the drug and the control
mask = np.isin(drug_name, [drug, control])
# Run all the tests
_effect = get_effect_sizes(feat[mask],
drug_dose[mask],
control=control_dose,
test=test,
comparison_type=comparison_type)
# Transpose df to have doses as index
_effect = _effect.T
_effect.index.rename('drug_dose', inplace=True)
effect[drug] = _effect.reset_index(drop=False)
# concatenate individual dataframes
effect = pd.concat(
[x.assign(drug_name=drug) for drug, x in effect.items()],
axis=0).reset_index(drop=True)
# bring drug name amd drug dose to the front
effect = effect[
['drug_name', 'drug_dose'] + \
effect.columns.difference(['drug_name', 'drug_dose']).to_list()
]
return effect
def control_variation(feat,
meta,
args,
variables=['date_yyyymmdd','instrument_name','imaging_run_number'],
n_sig_features=None):
""" Analyse variation in control data with respect to each categorical variable in 'variables'
Inputs
------
feat, meta : pd.DataFrame
Matching features summaries and metadata for control data
args : Object
Python object with the following attributes:
- remove_outliers : bool
- grouping_variable : str
- control_dict : dict
- test : str
- pval_threshold : float
- fdr_method : str
- n_sig_features : int
- n_top_feats : int
- drop_size_features : bool
- norm_features_only : bool
- percentile_to_use : str
- remove_outliers : bool
variables : list
List of categorical random variables to analyse variation in control data
"""
assert set(feat.index) == set(meta.index)
save_dir = get_save_dir(args) / "control"
# Stats test to use
assert args.test in ['ANOVA','Kruskal','LMM']
t_test = 't-test' if args.test == 'ANOVA' else 'Mann-Whitney' # aka. Wilcoxon rank-sums
for grouping_var in tqdm(variables):
# convert grouping variable column to factor (categorical)
meta[grouping_var] = meta[grouping_var].astype(str)
# get control group for eg. date_yyyymmdd
control_group = str(args.control_dict[grouping_var])
print("\nInvestigating variation in '%s' (control: '%s')" % (grouping_var, control_group))
# Record mean sample size per group
mean_sample_size = int(np.round(meta.groupby([grouping_var]).size().mean()))
print("Mean sample size: %d" % mean_sample_size)
group_list = list(meta[grouping_var].unique())
stats_dir = save_dir / "Stats" / grouping_var
plot_dir = save_dir / "Plots" / grouping_var
##### STATISTICS #####
stats_path = stats_dir / '{}_results.csv'.format(args.test) # LMM/ANOVA/Kruskal
ttest_path = stats_dir / '{}_results.csv'.format(t_test)
if not np.logical_and(stats_path.exists(), ttest_path.exists()):
stats_path.parent.mkdir(exist_ok=True, parents=True)
ttest_path.parent.mkdir(exist_ok=True, parents=True)
### ANOVA / Kruskal-Wallis tests for significantly different features across groups
if (args.test == "ANOVA" or args.test == "Kruskal"):
if len(group_list) > 2:
stats, pvals, reject = univariate_tests(X=feat,
y=meta[grouping_var],
control=control_group,
test=args.test,
comparison_type='multiclass',
multitest_correction=args.fdr_method,
alpha=0.05)
# get effect sizes
effect_sizes = get_effect_sizes(X=feat,
y=meta[grouping_var],
control=control_group,
effect_type=None,
linked_test=args.test)
anova_table = pd.concat([stats, effect_sizes, pvals, reject], axis=1)
anova_table.columns = ['stats','effect_size','pvals','reject']
anova_table['significance'] = sig_asterix(anova_table['pvals'])
# Sort pvals + record significant features
anova_table = anova_table.sort_values(by=['pvals'], ascending=True)
fset = list(anova_table['pvals'].index[np.where(anova_table['pvals'] <
args.pval_threshold)[0]])
# Save statistics results + significant feature set to file
anova_table.to_csv(stats_path, header=True, index=True)
if len(fset) > 0:
anova_sigfeats_path = Path(str(stats_path).replace('_results.csv', '_sigfeats.txt'))
write_list_to_file(fset, anova_sigfeats_path)
print("\n%d significant features found by %s for '%s' (P<%.2f, %s)" %\
(len(fset), args.test, grouping_var, args.pval_threshold, args.fdr_method))
else:
fset = []
print("\nWARNING: Not enough groups for %s for '%s' (n=%d groups)" %\
(args.test, grouping_var, len(group_list)))
### t-tests / Mann-Whitney tests
if len(fset) > 0 or len(group_list) == 2:
stats_t, pvals_t, reject_t = univariate_tests(X=feat,
y=meta[grouping_var],
control=control_group,
test=t_test,
comparison_type='binary_each_group',
multitest_correction=args.fdr_method,
alpha=0.05)
effect_sizes_t = get_effect_sizes(X=feat, y=meta[grouping_var],
control=control_group,
effect_type=None,
linked_test=t_test)
stats_t.columns = ['stats_' + str(c) for c in stats_t.columns]
pvals_t.columns = ['pvals_' + str(c) for c in pvals_t.columns]
reject_t.columns = ['reject_' + str(c) for c in reject_t.columns]
effect_sizes_t.columns = ['effect_size_' + str(c) for c in effect_sizes_t.columns]
ttest_table = pd.concat([stats_t, effect_sizes_t, pvals_t, reject_t], axis=1)
# Record t-test significant feature set (NOT ORDERED)
fset_ttest = list(pvals_t.index[(pvals_t < args.pval_threshold).sum(axis=1) > 0])
# Save t-test results to file
ttest_table.to_csv(ttest_path, header=True, index=True) # Save test results to CSV
if len(fset_ttest) > 0:
ttest_sigfeats_path = Path(str(ttest_path).replace('_results.csv', '_sigfeats.txt'))
write_list_to_file(fset_ttest, ttest_sigfeats_path)
print("%d signficant features found for any %s vs %s (%s, P<%.2f)" %\
(len(fset_ttest), grouping_var, control_group, t_test, args.pval_threshold))
# Barplot of number of significantly different features for each strain
barplot_sigfeats(test_pvalues_df=pvals_t,
saveDir=plot_dir,
p_value_threshold=args.pval_threshold,
test_name=t_test)
### Load statistics results
# Read ANOVA results and record significant features
print("\nLoading statistics results")
if len(group_list) > 2:
anova_table = pd.read_csv(stats_path, index_col=0)
pvals = anova_table.sort_values(by='pvals', ascending=True)['pvals']
fset = pvals[pvals < args.pval_threshold].index.to_list()
print("%d significant features found by %s (P<%.2f)" % (len(fset), args.test,
args.pval_threshold))
# Read t-test results and record significant features (NOT ORDERED)
ttest_table = pd.read_csv(ttest_path, index_col=0)
pvals_t = ttest_table[[c for c in ttest_table if "pvals_" in c]]
fset_ttest = pvals_t[(pvals_t < args.pval_threshold).sum(axis=1) > 0].index.to_list()
print("%d significant features found by %s (P<%.2f)" % (len(fset_ttest), t_test, args.pval_threshold))
# Use t-test significant feature set if comparing just 2 strains
if len(group_list) == 2:
fset = fset_ttest
if not n_sig_features:
if args.n_sig_features is not None:
n_sig_features = args.n_sig_features
else:
n_sig_features = len(fset)
##### Plotting #####
superplot_dir = plot_dir / 'superplots'
if len(fset) > 1:
for feature in tqdm(fset[:n_sig_features]):
# plot variation in variable with respect to 'date_yyyymmdd'
superplot(feat, meta, feature,
x1=grouping_var,
x2=None if grouping_var == 'date_yyyymmdd' else 'date_yyyymmdd',
saveDir=superplot_dir,
pvals=pvals_t if grouping_var == 'date_yyyymmdd' else None,
pval_threshold=args.pval_threshold,
show_points=True,
plot_means=True,
dodge=True)
# plot variation in variable with respect to 'instrument_name'
superplot(feat, meta, feature,
x1=grouping_var,
x2=None if grouping_var == 'instrument_name' else 'instrument_name',
saveDir=superplot_dir,
pvals=pvals_t if grouping_var == 'instrument_name' else None,
pval_threshold=args.pval_threshold,
show_points=True,
plot_means=True,
dodge=True)
# plot variation in variable with respect to 'imaging_ruun_number'
superplot(feat, meta, feature,
x1=grouping_var,
x2=None if grouping_var == 'imaging_run_number' else 'imaging_run_number',
saveDir=superplot_dir,
pvals=pvals_t if grouping_var == 'imaging_run_number' else None,
pval_threshold=args.pval_threshold,
show_points=True,
plot_means=True,
dodge=True)
# # Boxplots of significant features by ANOVA/LMM (all groups)
# boxplots_grouped(feat_meta_df=meta.join(feat),
# group_by=grouping_var,
# control_group=str(control_group),
# test_pvalues_df=pvals_t.T, # ranked by test pvalue significance
# feature_set=fset,
# saveDir=(plot_dir / 'grouped_boxplots'),
# max_feats2plt=args.n_sig_features,
# max_groups_plot_cap=None,
# p_value_threshold=args.pval_threshold,
# drop_insignificant=False,
# sns_colour_palette="tab10",
# figsize=[6, (len(group_list)/3 if len(group_list)>10 else 12)])
# Individual boxplots of significant features by pairwise t-test (each group vs control)
# boxplots_sigfeats(feat_meta_df=meta.join(feat),
# test_pvalues_df=pvals_t,
# group_by=grouping_var,
# control_strain=control_group,
# feature_set=fset, #['speed_norm_50th_bluelight'],
# saveDir=plot_dir / 'paired_boxplots',
# max_feats2plt=args.n_sig_features,
# p_value_threshold=args.pval_threshold,
# drop_insignificant=True,
# verbose=False)
# from tierpsytools.analysis.significant_features import plot_feature_boxplots
# plot_feature_boxplots(feat_to_plot=fset,
# y_class=grouping_var,
# scores=pvalues.rank(axis=1),
# feat=feat,
# pvalues=np.asarray(pvalues).flatten(),
# saveto=None,
# close_after_plotting=False)
##### Hierarchical Clustering Analysis #####
print("\nPerforming hierarchical clustering analysis...")
assert not feat.isna().sum(axis=1).any()
assert not (feat.std(axis=1) == 0).any()
# Z-normalise data
featZ = feat.apply(zscore, axis=0)
#featZ = (feat-feat.mean())/feat.std() # minus mean, divide by std
#from tierpsytools.preprocessing.scaling_class import scalingClass
#scaler = scalingClass(scaling='standardize')
#featZ = scaler.fit_transform(feat)
# NOT NEEDED?
# # Drop features with NaN values after normalising
# n_cols = len(featZ.columns)
# featZ.dropna(axis=1, inplace=True)
# n_dropped = n_cols - len(featZ.columns)
# if n_dropped > 0:
# print("Dropped %d features after normalisation (NaN)" % n_dropped)
### Control clustermap
# control data is clustered and feature order is stored and applied to full data
if len(group_list) > 1 and len(group_list) < 50 and grouping_var != 'date_yyyymmdd':
control_clustermap_path = plot_dir / 'heatmaps' / (grouping_var + '_date_clustermap.pdf')
cg = plot_clustermap(featZ, meta,
group_by=([grouping_var] if grouping_var == 'date_yyyymmdd'
else [grouping_var, 'date_yyyymmdd']),
col_linkage=None,
method=METHOD,#[linkage, complete, average, weighted, centroid]
metric=METRIC,
figsize=[15,8],
sub_adj={'bottom':0.02,'left':0.02,'top':1,'right':0.85},
label_size=12,
show_xlabels=False,
saveto=control_clustermap_path)
#col_linkage = cg.dendrogram_col.calculated_linkage
clustered_features = np.array(featZ.columns)[cg.dendrogram_col.reordered_ind]
else:
clustered_features = None
## Save z-normalised values
# z_stats = featZ.join(meta[grouping_var]).groupby(by=grouping_var).mean().T
# z_stats.columns = ['z-mean_' + v for v in z_stats.columns.to_list()]
# z_stats.to_csv(z_stats_path, header=True, index=None)
# Clustermap of full data
full_clustermap_path = plot_dir / 'heatmaps' / (grouping_var + '_clustermap.pdf')
fg = plot_clustermap(featZ, meta,
group_by=grouping_var,
col_linkage=None,
method=METHOD,
metric=METRIC,
figsize=[15,8],
sub_adj={'bottom':0.02,'left':0.02,'top':1,'right':0.9},
label_size=12,
saveto=full_clustermap_path)
# If no control clustering (due to no day variation) then use clustered features for all
# strains to order barcode heatmaps
if clustered_features is None:
clustered_features = np.array(featZ.columns)[fg.dendrogram_col.reordered_ind]
if len(group_list) > 2:
pvals_heatmap = anova_table.loc[clustered_features, 'pvals']
elif len(group_list) == 2:
pvals_heatmap = pvals_t.loc[clustered_features, pvals_t.columns[0]]
pvals_heatmap.name = 'P < {}'.format(args.pval_threshold)
assert all(f in featZ.columns for f in pvals_heatmap.index)
# Plot barcode heatmap (grouping by date)
if len(group_list) > 1 and len(group_list) < 50 and grouping_var != 'date_yyyymmdd':
heatmap_date_path = plot_dir / 'heatmaps' / (grouping_var + '_date_heatmap.pdf')
plot_barcode_heatmap(featZ=featZ[clustered_features],
meta=meta,
group_by=[grouping_var, 'date_yyyymmdd'],
pvalues_series=pvals_heatmap,
p_value_threshold=args.pval_threshold,
selected_feats=fset if len(fset) > 0 else None,
saveto=heatmap_date_path,
figsize=[20,7],
sns_colour_palette="Pastel1")
# Plot group-mean heatmap (averaged across days)
heatmap_path = plot_dir / 'heatmaps' / (grouping_var + '_heatmap.pdf')
plot_barcode_heatmap(featZ=featZ[clustered_features],
meta=meta,
group_by=[grouping_var],
pvalues_series=pvals_heatmap,
p_value_threshold=args.pval_threshold,
selected_feats=fset if len(fset) > 0 else None,
saveto=heatmap_path,
figsize=[20, (int(len(group_list) / 4) if len(group_list) > 10 else 6)],
sns_colour_palette="Pastel1")
##### Principal Components Analysis #####
print("Performing principal components analysis")
if args.remove_outliers:
outlier_path = plot_dir / 'mahalanobis_outliers.pdf'
feat, inds = remove_outliers_pca(df=feat,
features_to_analyse=None,
saveto=outlier_path)
meta = meta.reindex(feat.index) # reindex metadata
featZ = feat.apply(zscore, axis=0) # re-normalise data
# Drop features with NaN values after normalising
n_cols = len(featZ.columns)
featZ.dropna(axis=1, inplace=True)
n_dropped = n_cols - len(featZ.columns)
if n_dropped > 0:
print("Dropped %d features after normalisation (NaN)" % n_dropped)
#from tierpsytools.analysis.decomposition import plot_pca
pca_dir = plot_dir / 'PCA'
_ = plot_pca(featZ, meta,
group_by=grouping_var,
control=control_group,
var_subset=None,
saveDir=pca_dir,
PCs_to_keep=10,
n_feats2print=10,
sns_colour_palette="plasma",
n_dims=2,
label_size=15,
figsize=[9,8],
sub_adj={'bottom':0.13,'left':0.12,'top':0.98,'right':0.98},
# legend_loc='upper right',
# n_colours=20,
hypercolor=False)
