def stats_fmri(corrs, permutation=True, iter=5000):
"""
Calculate the statistical results for fMRI
Parameters
----------
corrs : array
The correlation coefficients.
The shape of corrs must be [n_subs, n_x, n_y, n_z, 2]. n_subs, n_x, n_y, n_z represent the number of subjects,
the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 5000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for
searchlight along the x, y, z axis and 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 6.
This function can be used for the results of searchlight fMRI NPS and searchlight fMRI RDM-correlations.
"""
# get the number of subjects
subs = np.shape(corrs)[0]
# subs>=6
if subs < 6:
return print("the number of subjects is too small!")
# get the number of the calculation units in the x, y, z directions
n_x, n_y, n_z = np.shape(corrs)[1:4]
# initialize the corrs
stats = np.zeros([n_x, n_y, n_z, 2], dtype=np.float)
# get r-map
rs = corrs[:, :, :, :, 0]
# Fisher r to z
zs = 0.5 * np.log((1 + rs) / (1 - rs))
# calculate the statistical results
for i in range(n_x):
for j in range(n_y):
for k in range(n_z):
# t test
stats[i, j, k] = ttest_1samp(zs[:, i, j, k], 0)
if permutation == True:
stats[i, j, k, 1] = permutation_test(zs[:, i, j, k],
np.zeros([subs]),
iter=iter)
return stats
def stats(corrs, permutation=True, iter=5000):
"""
Calculate the statistical results
Parameters
----------
corrs : array
The correlation coefficients.
The shape of corrs must be [n_subs, n_chls, n_ts, 2]. n_subs, n_chls, n_ts represent the number of subjects, the
number of channels and the number of time-points. 2 represents a r-value and a p-value.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 5000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_chls, n_ts, 2]. n_chls, n_ts represent the number of channels and the number of
time-points. 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 6.
This function can be used for the correlation results of NPS, ISC, eeg-like RDMs-correlations.
"""
# get the number of subjects, channels & time-points
subs, chls, ts = np.shape(corrs)[:3]
# subs>=6
if subs < 6:
return print("the number of subjects is too small!")
# initialize the corrs
stats = np.zeros([chls, ts, 2], dtype=np.float)
# get r-map
rs = corrs[:, :, :, 0]
#print(zs)
# calculate the statistical results
for i in range(chls):
for j in range(ts):
# t test
stats[i, j] = ttest_1samp(rs[:, i, j], 0)
if permutation == True:
# Fisher r to z
zs = 0.5 * np.log((1 + rs) / (1 - rs))
stats[i, j, 1] = permutation_test(zs[:, i, j],
np.zeros([subs]),
iter=iter)
return stats
def plot_tbytresults(decoding_results_dir, subs):
f = h5py.File(decoding_results_dir, "r")
nsubs = len(subs)
rlts = np.zeros([nsubs, 100], dtype=np.float)
subindex = 0
for sub in subs:
rlts[subindex] = np.array(f[sub])
for t in range(100):
if t <= 1:
rlts[subindex, t] = np.average(rlts[subindex, :t + 3])
if t > 1 and t < 98:
rlts[subindex, t] = np.average(rlts[subindex, t - 2:t + 3])
if t >= 98:
rlts[subindex, t] = np.average(rlts[subindex, t - 2:])
subindex = subindex + 1
f.close()
avg = np.average(rlts, axis=0)
err = np.zeros([100], dtype=np.float)
for t in range(100):
err[t] = np.std(rlts[:, t], ddof=1) / np.sqrt(nsubs)
ps = np.zeros([100], dtype=np.float)
chance = np.full([16], 0.0625)
for t in range(100):
ps[t] = permutation_test(rlts[:, t], chance)
if ps[t] < 0.05 and avg[t] > 0.0625:
plt.plot(t * 0.02 - 0.5, 0.148, "s", color="orangered", alpha=0.8)
xi = [t * 0.02 - 0.5, t * 0.02 + 0.02 - 0.5]
ymin = [0.0625]
ymax = [avg[t] - err[t]]
plt.fill_between(xi, ymax, ymin, facecolor="orangered", alpha=0.15)
ax = plt.gca()
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["left"].set_linewidth(3)
ax.spines["bottom"].set_linewidth(3)
ax.spines['bottom'].set_position(('data', 0.0625))
x = np.arange(-0.5 + 0.008, 1.5 + 0.008, 0.02)
plt.fill_between(x, avg + err, avg - err, facecolor="orangered", alpha=0.8)
plt.ylim(0.05, 0.15)
plt.xlim(-0.5, 1.5)
plt.xticks([-0.25, 0, 0.25, 0.5, 0.75, 1, 1.25, 1.5])
plt.tick_params(labelsize=12)
plt.xlabel("Time (s)", fontsize=16)
plt.ylabel("Classification Accuracy", fontsize=16)
plt.show()
def stats_stps(corrs1, corrs2, permutation=True, iter=5000):
"""
Calculate the statistical results （for STPS）
Parameters
----------
corrs1 : array
The correlation coefficients under condition1.
The shape of corrs1 must be [n_subs, n_chls, n_ts]. n_subs, n_chls, n_ts represent the number of subjects, the
number of channels and the number of time-points.
corrs2 : array
The correlation coefficients under condition2.
The shape of corrs2 must be [n_subs, n_chls, n_ts]. n_subs, n_chls, n_ts represent the number of subjects, the
number of channels and the number of time-points.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 5000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_chls, n_ts, 2]. n_chls, n_ts represent the number of channels and the number of
time-points. 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 6.
"""
# get the number of subjects, channels & time-points
subs, chls, ts = np.shape(corrs1)
# subs>=6
if subs < 6:
return print("the number of subjects is too small!")
# initialize the corrs
stats = np.zeros([chls, ts, 2], dtype=np.float)
# get r-map
rs1 = corrs1
rs2 = corrs2
# calculate the statistical results
for i in range(chls):
for j in range(ts):
# t test
stats[i, j] = ttest_rel(rs1[:, i, j], rs2[:, i, j])
if permutation == True:
# Fisher r to z
zs1 = 0.5 * np.log((1 + rs1) / (1 - rs1))
zs2 = 0.5 * np.log((1 + rs2) / (1 - rs2))
stats[i, j, 1] = permutation_test(zs1[:, i, j],
zs2[:, i, j],
iter=iter)
return stats
def stats_iscfmri(corrs, permutation=True, iter=5000):
"""
Calculate the statistical results for fMRI (ISC searchlight)
Parameters
----------
corrs : array
The correlation coefficients.
The shape of corrs must be [n_ts, n_subs!/(2!*(n_subs-2)!), n_x, n_y, n_z, 2]. n_ts, n_subs, n_x, n_y, n_z
represent the number of subjects, the number of calculation units for searchlight along the x, y, z axis and 2
represents a r-value and a p-value.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 5000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_ts, n_x, n_y, n_z, 2]. n_ts, n_x, n_y, n_z represent the number of time-points, the
number of calculation units for searchlight along the x, y, z axis and 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 4 (n_subs!/(2!*(n_subs-2)!) >= 6).
"""
# get the number of time-points, pairs
ts, npairs = np.shape(corrs)[:2]
# n_subs!/(2!*(n_subs-2)!)>=6
if npairs < 6:
return print("the number of subjects is too small!")
# get the number of the calculation units in the x, y, z directions
n_x, n_y, n_z = np.shape(corrs)[2:5]
# initialize the corrs
stats = np.zeros([ts, n_x, n_y, n_z, 2], dtype=np.float)
# get r-map
rs = corrs[:, :, :, :, :, 0]
# calculate the statistical results
for t in range(ts):
for i in range(n_x):
for j in range(n_y):
for k in range(n_z):
# t test
stats[t, i, j, k] = ttest_1samp(rs[t, :, i, j, k], 0)
if permutation == True:
# Fisher r to z
zs = 0.5 * np.log((1 + rs) / (1 - rs))
stats[t, i, j, k,
1] = permutation_test(zs[t, :, i, j, k],
np.zeros([npairs]),
iter=iter)
return stats
def stats_stps(corrs1, corrs2, fisherz=True, permutation=True, iter=1000):
"""
Conduct the statistical analysis for results of EEG-like data（for STPS）
Parameters
----------
corrs1 : array
The correlation coefficients under condition1.
The shape of corrs1 must be [n_subs, n_chls, n_ts]. n_subs, n_chls, n_ts represent the number of subjects, the
number of channels and the number of time-points.
corrs2 : array
The correlation coefficients under condition2.
The shape of corrs2 must be [n_subs, n_chls, n_ts]. n_subs, n_chls, n_ts represent the number of subjects, the
number of channels and the number of time-points.
fisherz : bool True or False. Default is True.
Conduct Fisher-Z transform.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 1000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_chls, n_ts, 2]. n_chls, n_ts represent the number of channels and the number of
time-points. 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 6.
"""
if len(np.shape(corrs1)) != 3 or len(np.shape(corrs2)) != 3 or np.shape(corrs1)[1] != np.shape(corrs2)[1] or \
np.shape(corrs1)[2] != np.shape(corrs2)[2]:
return "Invalid input!"
# get the number of subjects, channels & time-points
subs, chls, ts = np.shape(corrs1)
# subs>=6
if subs < 6:
return print("the number of subjects is too small!")
# initialize the corrs
stats = np.zeros([chls, ts, 2], dtype=np.float)
# get r-map
rs1 = corrs1
rs2 = corrs2
if fisherz == True:
# Fisher r to z
rs1 = 0.5 * np.log((1 + rs1) / (1 - rs1))
rs2 = 0.5 * np.log((1 + rs2) / (1 - rs2))
# calculate the statistical results
for i in range(chls):
for j in range(ts):
# t test
stats[i, j] = ttest_rel(rs1[:, i, j], rs2[:, i, j])
if permutation == True:
stats[i, j, 1] = permutation_test(rs1[:, i, j],
rs2[:, i, j],
iter=iter)
return stats
def stats_fmri_compare_betweengroups(corrs1,
corrs2,
fisherz=True,
permutation=False,
iter=5000):
"""
Conduct the statistical analysis for results of fMRI data (searchlight) (between 2 groups: group1 > group2)
Parameters
----------
corrs1 : array
The correlation coefficients for group 1.
The shape of corrs must be [n_subs, n_x, n_y, n_z, 2]. n_subs, n_x, n_y, n_z represent the number of subjects,
the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value.
corrs2 : array
The correlation coefficients for group 2.
The shape of corrs must be [n_subs, n_x, n_y, n_z, 2]. n_subs, n_x, n_y, n_z represent the number of subjects,
the number of calculation units for searchlight along the x, y, z axis and 2 represents a r-value and a p-value.
fisherz : bool True or False. Default is True.
Conduct Fisher-Z transform.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 5000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_x, n_y, n_z, 2]. n_x, n_y, n_z represent the number of calculation units for
searchlight along the x, y, z axis and 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 6.
This function can be used for the results of searchlight fMRI NPS and searchlight fMRI RDM-correlations.
"""
if len(np.shape(corrs1)) != 5 or len(np.shape(corrs2)) != 5:
return "Invalid input!"
# get the number of subjects
subs1 = np.shape(corrs1)[0]
subs2 = np.shape(corrs2)[0]
# subs>=6
if subs1 < 6 or subs2 < 6:
return print("the number of subjects is too small!")
# get the number of the calculation units in the x, y, z directions
n_x, n_y, n_z = np.shape(corrs1)[1:4]
# initialize the corrs
stats = np.zeros([n_x, n_y, n_z, 2], dtype=np.float)
# get r-map
rs1 = corrs1[:, :, :, :, 0]
rs2 = corrs2[:, :, :, :, 0]
if fisherz == True:
rs1 = 0.5 * np.log((1 + rs1) / (1 - rs1))
rs2 = 0.5 * np.log((1 + rs2) / (1 - rs2))
# calculate the statistical results
for i in range(n_x):
for j in range(n_y):
for k in range(n_z):
# t test
stats[i, j, k] = ttest_ind(rs1[:, i, j, k],
rs2[:, i, j, k],
alternative="greater")
if permutation == True:
stats[i, j, k, 1] = permutation_test(rs1[:, i, j, k],
rs2[:, i, j, k],
iter=iter)
return stats
def stats(corrs, fisherz=True, permutation=True, iter=1000):
"""
Conduct the statistical analysis for results of EEG-like data
Parameters
----------
corrs : array
The correlation coefficients.
The shape of corrs must be [n_subs, n_chls, n_ts, 2]. n_subs, n_chls, n_ts represent the number of subjects, the
number of channels and the number of time-points. 2 represents a r-value and a p-value.
fisherz : bool True or False. Default is True.
Conduct Fisher-Z transform.
permutation : bool True or False. Default is False.
Use permutation test or not.
iter : int. Default is 1000.
The times for iteration.
Returns
-------
stats : array
The statistical results.
The shape of stats is [n_chls, n_ts, 2]. n_chls, n_ts represent the number of channels and the number of
time-points. 2 represents a t-value and a p-value.
Notes
-----
n_subs must >= 6.
This function can be used for the correlation results of NPS, ISC, eeg-like RDMs-correlations.
"""
if len(np.shape(corrs)) != 4:
return "Invalid input!"
# get the number of subjects, channels & time-points
subs, chls, ts = np.shape(corrs)[:3]
# subs>=6
if subs < 6:
return print("the number of subjects is too small!")
# initialize the corrs
stats = np.zeros([chls, ts, 2], dtype=np.float)
# get r-map
rs = corrs[:, :, :, 0]
if fisherz == True:
rs = 0.5 * np.log((1 + rs) / (1 - rs))
#print(zs)
# calculate the statistical results
for i in range(chls):
for j in range(ts):
# t test
stats[i, j] = ttest_1samp(rs[:, i, j], 0, alternative="greater")
if permutation == True:
stats[i, j, 1] = permutation_test(rs[:, i, j],
np.zeros([subs]),
iter=iter)
return stats
def plot_tbytsim_withstats(Similarities,
start_time=0,
end_time=1,
color='r',
lim=[-0.1, 0.8]):
"""
Plot the time-by-time Similarities averaging all subjects
Parameters
----------
Similarities : array
The Similarities.
The size of Similarities should be [n_subs, n_ts] or [n_subs, n_ts, 2]. n_subs, n_ts represent the number of
subjects and number of time-points. 2 represents the similarity and a p-value.
start_time : int or float. Default is 0.
The start time.
end_time : int or float. Default is 1.
The end time.
color : matplotlib color or None. Default is 'r'.
The color for the curve.
lim : array or list [min, max]. Default is [-0.1, 0.8].
The corrs view lims.
"""
if len(np.shape(Similarities)) < 2 or len(np.shape(Similarities)) > 3:
return "Invalid input!"
n = len(np.shape(Similarities))
minlim = lim[0]
maxlim = lim[1]
if n == 3:
Similarities = Similarities[:, :, 0]
nsubs = np.shape(Similarities)[0]
nts = np.shape(Similarities)[1]
tstep = float((end_time - start_time) / nts)
for sub in range(nsubs):
for t in range(nts):
if t <= 1:
Similarities[sub, t] = np.average(Similarities[sub, :t + 3])
if t > 1 and t < (nts - 2):
Similarities[sub, t] = np.average(Similarities[sub,
t - 2:t + 3])
if t >= (nts - 2):
Similarities[sub, t] = np.average(Similarities[sub, t - 2:])
avg = np.average(Similarities, axis=0)
err = np.zeros([nts], dtype=np.float)
for t in range(nts):
err[t] = np.std(Similarities[:, t], ddof=1) / np.sqrt(nsubs)
ps = np.zeros([nts], dtype=np.float)
chance = np.full([nsubs], 0)
for t in range(nts):
ps[t] = permutation_test(Similarities[:, t], chance)
if ps[t] < 0.05 and avg[t] > 0:
plt.plot(t * tstep + start_time,
maxlim * 0.9,
's',
color=color,
alpha=1)
xi = [t * tstep + start_time, t * tstep + tstep + start_time]
ymin = [0]
ymax = [avg[t] - err[t]]
plt.fill_between(xi, ymax, ymin, facecolor=color, alpha=0.1)
ax = plt.gca()
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["left"].set_linewidth(3)
ax.spines["bottom"].set_linewidth(3)
ax.spines['bottom'].set_position(('data', 0))
x = np.arange(start_time + 0.5 * tstep, end_time + 0.5 * tstep, tstep)
plt.fill_between(x, avg + err, avg - err, facecolor=color, alpha=0.8)
plt.ylim(minlim, maxlim)
plt.xlim(start_time, end_time)
plt.tick_params(labelsize=12)
plt.xlabel("Time (s)", fontsize=16)
plt.ylabel("Representational Similarity", fontsize=16)
plt.show()
return 0
def test_permutation_test(self):
v1 = np.random.rand(20)
v2 = np.random.rand(20)
output = permutation_test(v1, v2)
self.assertIsNotNone(output)
