def test_watson_williams_nd():
dat1 = np.tile(np.radians([135., 145, 125, 140, 165, 170]), (3, 4, 1))
dat2 = np.tile(np.radians([150, 130, 175, 190, 180, 220]), (3, 4, 1))
dat3 = np.tile(np.radians([140, 165, 185, 180, 125, 175, 140]), (3, 4, 1))
p, T = pycircstat.watson_williams(dat1, dat2, dat3, axis=2)
assert_true(p.shape == (3, 4),
"return pvalue array does not have right shape")
assert_allclose(p, 0.1870637, atol=0.0001, rtol=0.0001)
def test_watson_williams_nd():
dat1 = np.tile(np.radians([135., 145, 125, 140, 165, 170]), (3, 4, 1))
dat2 = np.tile(np.radians([150, 130, 175, 190, 180, 220]), (3, 4, 1))
dat3 = np.tile(np.radians([140, 165, 185, 180, 125, 175, 140]), (3, 4, 1))
p, T = pycircstat.watson_williams(dat1, dat2, dat3, axis=2)
assert_true(
p.shape == (
3,
4),
"return pvalue array does not have right shape")
assert_allclose(p, 0.1870637, atol=0.0001, rtol=0.0001)
def my_ww_2samp(x1, x2, tag1, tag2):
n1, n2 = len(x1), len(x2)
sample_sizes = (n1, n2)
cmean1, cmean2 = circmean(x1), circmean(x2)
sem1, sem2 = circstd(x1) / np.sqrt(n1), circstd(x2) / np.sqrt(n2)
descrips = ((cmean1, sem1), (cmean2, sem2))
ww_results = watson_williams(x1, x2)
ww_pval, wwtable = ww_results
df_col = wwtable.loc['Columns', 'df']
df_Residual = wwtable.loc['Residual', 'df']
Fstat = wwtable.loc['Columns', 'F']
pval = wwtable.loc['Columns', 'p-value']
txt = r'Watson-Williams, %s $(n=%d)$ vs %s $(n=%d)$, $F_{(%d, %d)}=%0.2f, p=%s$' % (
tag1, n1, tag2, n2, df_col, df_Residual, Fstat, p2str(pval))
return ww_pval, sample_sizes, descrips, txt
def _compute_novel_rep_spike_stats(novel_phases, rep_phases):
# compute rayleigh test for each condition
p_novel, z_novel = pycircstat.rayleigh(novel_phases, axis=0)
p_rep, z_rep = pycircstat.rayleigh(rep_phases, axis=0)
# test whether the means are different
ww_pvals, ww_tables = pycircstat.watson_williams(novel_phases, rep_phases, axis=0)
ww_fstat = np.array([x.loc['Columns'].F for x in ww_tables])
# test whether the medians are different
med_pvals, med_stat = pycircstat.cmtest(novel_phases, rep_phases, axis=0)
# finall run kuiper test for difference in mean and/or dispersion
p_kuiper, stat_kuiper = pycircstat.kuiper(novel_phases, rep_phases, axis=0)
return p_novel, z_novel, p_rep, z_rep, ww_pvals, ww_fstat, med_pvals, med_stat, p_kuiper, stat_kuiper
def compute_phase_stats_with_shuffle(events, spike_rel_times, phase_data_hilbert, phase_bin_start,
phase_bin_stop, do_permute=False, shuffle_type=1):
spike_rel_times_tmp = spike_rel_times.copy()
e_tmp = events.copy()
if do_permute:
if shuffle_type == 1:
# permute the novel
novel_events = np.where(events.isFirst.values)[0]
perm_novel_events = np.random.permutation(novel_events)
spike_rel_times_tmp[novel_events] = spike_rel_times_tmp[perm_novel_events]
# and repeated separately
rep_events = np.where(~events.isFirst.values)[0]
perm_rep_events = np.random.permutation(rep_events)
spike_rel_times_tmp[rep_events] = spike_rel_times_tmp[perm_rep_events]
else:
e_tmp['isFirst'] = np.random.permutation(e_tmp.isFirst)
# get the phases at which the spikes occurred and bin into novel and repeated items for each hilbert band
spike_phases_hilbert = _compute_spike_phase_by_freq(spike_rel_times_tmp,
phase_bin_start,
phase_bin_stop,
phase_data_hilbert,
events)
# bin into repeated and novel phases
novel_phases, rep_phases = _bin_phases_into_cond(spike_phases_hilbert, e_tmp)
if (len(novel_phases) > 0) & (len(rep_phases) > 0):
# test phase locking for all spikes comboined
all_spikes_phases = np.vstack([novel_phases, rep_phases])
rayleigh_pval_all, rayleigh_z_all = pycircstat.rayleigh(all_spikes_phases, axis=0)
rvl_all = pycircstat.resultant_vector_length(all_spikes_phases, axis=0)
# rayleigh test for uniformity
rvl_novel = pycircstat.resultant_vector_length(novel_phases, axis=0)
rvl_rep = pycircstat.resultant_vector_length(rep_phases, axis=0)
rvl_diff = rvl_novel - rvl_rep
# compute rayleigh test for each condition
rayleigh_pval_novel, rayleigh_z_novel = pycircstat.rayleigh(novel_phases, axis=0)
rayleigh_pval_rep, rayleigh_z_rep = pycircstat.rayleigh(rep_phases, axis=0)
rayleigh_diff = rayleigh_z_novel - rayleigh_z_rep
# watson williams test for equal means
ww_pval, ww_tables = pycircstat.watson_williams(novel_phases, rep_phases, axis=0)
ww_fstat = np.array([x.loc['Columns'].F for x in ww_tables])
# kuiper test, to test for difference in dispersion (not mean, because I'm making them equal)
kuiper_pval, stat_kuiper = pycircstat.kuiper(novel_phases - pycircstat.mean(novel_phases),
rep_phases - pycircstat.mean(rep_phases), axis=0)
return (rvl_novel, rvl_rep, rvl_diff, ww_fstat, stat_kuiper, rayleigh_z_novel, rayleigh_z_rep, rayleigh_diff,
rayleigh_z_all, rvl_all), \
(rayleigh_pval_novel, rayleigh_pval_rep, ww_pval, kuiper_pval, rayleigh_pval_all), novel_phases, rep_phases
else:
return (np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2])), \
(np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2])), novel_phases, rep_phases
def test_watson_williams():
dat1 = np.radians([135., 145, 125, 140, 165, 170])
dat2 = np.radians([150, 130, 175, 190, 180, 220])
dat3 = np.radians([140, 165, 185, 180, 125, 175, 140])
p, T = pycircstat.watson_williams(dat1, dat2, dat3)
assert_allclose(p, 0.1870637, atol=0.001, rtol=0.001)
def compute_phase_stats_with_shuffle(events, spike_rel_times, phase_data_hilbert, phase_bin_start,
phase_bin_stop, do_permute=False):
spike_rel_times_tmp = spike_rel_times.copy()
if do_permute:
# permute the novel
novel_events = np.where(events.isFirst.values)[0]
perm_novel_events = np.random.permutation(novel_events)
spike_rel_times_tmp[novel_events] = spike_rel_times_tmp[perm_novel_events]
# and repeated separately
rep_events = np.where(~events.isFirst.values)[0]
perm_rep_events = np.random.permutation(rep_events)
spike_rel_times_tmp[rep_events] = spike_rel_times_tmp[perm_rep_events]
# get the phases at which the spikes occurred and bin into novel and repeated items for each hilbert band
spike_phases_hilbert = _compute_spike_phase_by_freq(spike_rel_times_tmp,
phase_bin_start,
phase_bin_stop,
phase_data_hilbert,
events)
# bin into repeated and novel phases
novel_phases, rep_phases = _bin_phases_into_cond(spike_phases_hilbert, events)
if (len(novel_phases) > 0) & (len(rep_phases) > 0):
# rayleigh test for uniformity
rvl_novel = pycircstat.resultant_vector_length(novel_phases, axis=0)
rvl_rep = pycircstat.resultant_vector_length(rep_phases, axis=0)
rvl_diff = rvl_novel - rvl_rep
# compute rayleigh test for each condition
rayleigh_pval_novel, rayleigh_z_novel = pycircstat.rayleigh(novel_phases, axis=0)
rayleigh_pval_rep, rayleigh_z_rep = pycircstat.rayleigh(rep_phases, axis=0)
rayleigh_diff = rayleigh_z_novel - rayleigh_z_rep
# watson williams test for equal means
ww_pval, ww_tables = pycircstat.watson_williams(novel_phases, rep_phases, axis=0)
ww_fstat = np.array([x.loc['Columns'].F for x in ww_tables])
# kuiper test, to test for difference in dispersion (not mean, because I'm making them equal)
kuiper_pval, stat_kuiper = pycircstat.kuiper(novel_phases - pycircstat.mean(novel_phases),
rep_phases - pycircstat.mean(rep_phases), axis=0)
return (rvl_novel, rvl_rep, rvl_diff, ww_fstat, stat_kuiper, rayleigh_z_novel, rayleigh_z_rep, rayleigh_diff), \
(rayleigh_pval_novel, rayleigh_pval_rep, ww_pval, kuiper_pval), novel_phases, rep_phases
else:
return (np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2])), \
(np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2]),
np.array([np.nan] * phase_data_hilbert.shape[2])), novel_phases, rep_phases
pars5['angle'] = phi
pars5 = pars5.dropna()
# stats on vector norm between laboratories:
sm_lm = ols('norm ~ C(institution_code)', data=pars5).fit()
table = sm.stats.anova_lm(sm_lm) # Type 2 ANOVA DataFrame
print(table)
# use pycircstat Watson-Williams test
pars6 = pars5.groupby('institution_code')['angle'].aggregate(
lambda x: list(x)).reset_index()
angles_grouped = pars6['angle'].values
pval, table = pycircstat.watson_williams(angles_grouped[0],
angles_grouped[1],
angles_grouped[2],
angles_grouped[3],
angles_grouped[4],
angles_grouped[5],
angles_grouped[6])
print('circular one-way anova')
print(table)
# fig, ax = plt.subplots(2, 1)
# sns.swarmplot(x='institution_code', y='norm', data=pars5, ax=ax[0])
# sns.swarmplot(x='institution_code', y='angle', data=pars5, ax=ax[1])
# fig.tight_layout()
# fig.savefig(os.path.join(figpath, "history_shift_stats.pdf"))
# fig.savefig(os.path.join(figpath, "history_shift_stats.png"), dpi=600)
# plt.close("all")
def plot_average_precession(self, NShuffles=1000):
fig_avercurve, ax_avercurve = plt.subplots(figsize=(figl, figl), sharey=True)
fig_phasesp, ax_phasesp = plt.subplots(figsize=(figl, figl), sharey=True)
anglediff, pass_nspikes = self.stack_anglediff(self.singlefield_df, precess_ref=True)
anglediff = np.abs(anglediff)
slopes = self.stack_key(self.singlefield_df, 'rcc_m')
offsets = self.stack_key(self.singlefield_df, 'rcc_c')
phasesp = np.concatenate(self.stack_key(self.singlefield_df, 'phasesp'))
low_mask = anglediff < (np.pi / 6)
high_mask = anglediff > (np.pi - np.pi / 6)
sample_size = 500
np.random.seed(1)
high_ranvec = np.random.choice(high_mask.sum(), size=sample_size)
low_ranvec = np.random.choice(low_mask.sum(), size=sample_size)
anglediff_spikes = repeat_arr(anglediff, pass_nspikes)
low_mask_sp = anglediff_spikes < (np.pi / 6)
high_mask_sp = anglediff_spikes > (np.pi - np.pi / 6)
phasesph = phasesp[high_mask_sp]
phasespl = phasesp[low_mask_sp]
slopes_high, offsets_high = slopes[high_mask][high_ranvec], offsets[high_mask][high_ranvec]
slopes_low, offsets_low = slopes[low_mask][low_ranvec], offsets[low_mask][low_ranvec]
regress_high, regress_low, pval_slope, pval_offset = permutation_test_average_slopeoffset(
slopes_high, offsets_high, slopes_low, offsets_low, NShuffles=NShuffles)
xdum = np.linspace(0, 1, 10)
high_agg_ydum = 2 * np.pi * regress_high['aopt'] * xdum + regress_high['phi0']
low_agg_ydum = 2 * np.pi * regress_low['aopt'] * xdum + regress_low['phi0']
# Compare high vs low
ax_avercurve.plot(xdum, high_agg_ydum, c='lime', label='$|d|>5\pi/6$')
ax_avercurve.plot(xdum, low_agg_ydum, c='darkblue', label='$|d|<\pi/6$')
ax_avercurve.text(0.05, -np.pi + 0.5, 'Slope\n p%s\nOffset\n p%s'% \
(p2str(pval_slope), p2str(pval_offset)), fontsize=legendsize)
customlegend(ax_avercurve, fontsize=legendsize, loc='center right')
#
aedges = np.linspace(-np.pi, np.pi, 36)
fstat, k_pval = circ_ktest(phasesph, phasespl)
p_ww, ww_table = watson_williams(phasesph, phasespl)
ax_phasesp.hist(phasesph, bins=aedges, density=True, histtype='step', color='lime')
ax_phasesp.hist(phasespl, bins=aedges, density=True, histtype='step', color='darkblue')
ax_phasesp.text(0.2, 0.15, 'Bartlett\'s\np%s'%(p2str(k_pval)), transform=ax_phasesp.transAxes, fontsize=fontsize)
# ax_phasesp.legend(fontsize=legendsize-2, loc='lower center')
ax_phasesp.set_xticks([-np.pi, 0, np.pi])
ax_phasesp.set_xticklabels(['$-\pi$', '0', '$\pi$'])
# ax_phasesp.set_yticks([0, 0.2])
ax_phasesp.tick_params(labelsize=ticksize, direction='inout')
ax_phasesp.set_xlabel('Phase (rad)', fontsize=fontsize)
ax_phasesp.set_ylabel('Normalized frequency', fontsize=fontsize)
ax_phasesp.set_xlim(-np.pi, np.pi)
ax_avercurve.set_xlim(0, 1)
ax_avercurve.set_ylim(-np.pi, np.pi + np.pi/2)
ax_avercurve.set_yticks([-np.pi, 0, np.pi])
ax_avercurve.set_yticklabels(['$-\pi$', '0', '$\pi$'])
ax_avercurve.set_xlabel('Position', fontsize=fontsize)
ax_avercurve.tick_params(labelsize=ticksize, direction='inout')
ax_avercurve.set_ylabel('Phase (rad)', fontsize=fontsize)
fig_avercurve.tight_layout()
fig_avercurve.savefig(join(self.plot_dir, 'Networks_aver_precess_curve.png'), dpi=300)
fig_phasesp.tight_layout()
fig_phasesp.savefig(join(self.plot_dir, 'Networks_spike_phase_highlow.png'), dpi=300)
plt.close()
