def test_isc_output():
logger.info("Testing ISC outputs")
data = correlated_timeseries(20, 60, noise=0,
random_state=42)
iscs = isc(data, pairwise=False)
assert np.allclose(iscs[:, :2], 1., rtol=1e-05)
assert np.all(iscs[:, -1] < 1.)
iscs = isc(data, pairwise=True)
assert np.allclose(iscs[:, :2], 1., rtol=1e-05)
assert np.all(iscs[:, -1] < 1.)
logger.info("Finished testing ISC outputs")
def test_isc_input():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
random_state = 42
logger.info("Testing ISC inputs")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=None, data_type='list',
random_state=random_state)
iscs_list = isc(data, pairwise=False, summary_statistic=None)
# Array of subjects with one voxel/ROI
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=None, data_type='array',
random_state=random_state)
iscs_array = isc(data, pairwise=False, summary_statistic=None)
# Check they're the same
assert np.array_equal(iscs_list, iscs_array)
# List of subjects with multiple voxels/ROIs
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='list',
random_state=random_state)
iscs_list = isc(data, pairwise=False, summary_statistic=None)
# Array of subjects with multiple voxels/ROIs
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
iscs_array = isc(data, pairwise=False, summary_statistic=None)
# Check they're the same
assert np.array_equal(iscs_list, iscs_array)
logger.info("Finished testing ISC inputs")
def test_phaseshift_isc():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
logger.info("Testing phase randomization")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array')
observed, p, distribution = phaseshift_isc(data, pairwise=True,
summary_statistic='median',
n_shifts=200)
# Phase randomization one-sample test, leave-one-out
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array')
observed, p, distribution = phaseshift_isc(data, pairwise=False,
summary_statistic='mean',
n_shifts=200)
# Check output p-values
data = correlated_timeseries(20, 60, noise=.5,
random_state=42)
iscs = isc(data, pairwise=False)
observed, p, distribution = phaseshift_isc(data, pairwise=False)
assert np.all(iscs[:, :2] > .5)
assert np.all(iscs[:, -1] < .5)
assert p[0] < .05 and p[1] < .05
assert p[2] > .01
iscs = isc(data, pairwise=True)
observed, p, distribution = phaseshift_isc(data, pairwise=True)
assert np.all(iscs[:, :2] > .5)
assert np.all(iscs[:, -1] < .5)
assert p[0] < .05 and p[1] < .05
assert p[2] > .01
# Check that ISC computation and permutation observed are same
iscs = isc(data, pairwise=False)
observed, p, distribution = phaseshift_isc(data, pairwise=False,
summary_statistic='median')
assert np.allclose(observed, isc(data, pairwise=False,
summary_statistic='median'),
rtol=1e-03)
# Check that ISC computation and permuation observed are same
iscs = isc(data, pairwise=True)
observed, p, distribution = phaseshift_isc(data, pairwise=True,
summary_statistic='mean')
assert np.allclose(observed, isc(data, pairwise=True,
summary_statistic='mean'),
rtol=1e-03)
logger.info("Finished testing phase randomization")
def test_squareform_isfc():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
random_state = 42
logger.info("Testing ISC options")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
# Generate square redundant ISFCs
isfcs_r = isfc(data, vectorize_isfcs=False)
assert isfcs_r.shape == (n_subjects, n_voxels, n_voxels)
# Squareform these into condensed ISFCs and ISCs
isfcs_c, iscs_c = squareform_isfc(isfcs_r)
assert isfcs_c.shape == (n_subjects, n_voxels * (n_voxels - 1) / 2)
assert iscs_c.shape == (n_subjects, n_voxels)
# Go back the other way and check it's the same
isfcs_new = squareform_isfc(isfcs_c, iscs_c)
assert np.array_equal(isfcs_r, isfcs_new)
# Check against ISC function
assert np.allclose(isc(data), iscs_c, rtol=1e-03)
# Check for two subjects
isfcs_r = isfc(data[..., :2], vectorize_isfcs=False)
assert isfcs_r.shape == (n_voxels, n_voxels)
isfcs_c, iscs_c = squareform_isfc(isfcs_r)
assert isfcs_c.shape == (n_voxels * (n_voxels - 1) / 2,)
assert iscs_c.shape == (n_voxels,)
assert np.array_equal(isfcs_r, squareform_isfc(isfcs_c, iscs_c))
def test_isc_options():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
random_state = 42
logger.info("Testing ISC options")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
iscs_loo = isc(data, pairwise=False, summary_statistic=None)
assert iscs_loo.shape == (n_subjects, n_voxels)
# Just two subjects
iscs_loo = isc(data[..., :2], pairwise=False, summary_statistic=None)
assert iscs_loo.shape == (n_voxels,)
iscs_pw = isc(data, pairwise=True, summary_statistic=None)
assert iscs_pw.shape == (n_subjects*(n_subjects-1)/2, n_voxels)
# Check summary statistics
isc_mean = isc(data, pairwise=False, summary_statistic='mean')
assert isc_mean.shape == (n_voxels,)
isc_median = isc(data, pairwise=False, summary_statistic='median')
assert isc_median.shape == (n_voxels,)
try:
isc(data, pairwise=False, summary_statistic='min')
except ValueError:
logger.info("Correctly caught unexpected summary statistic")
logger.info("Finished testing ISC options")
def test_isfc_options():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
logger.info("Testing ISFC options")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array')
isfcs, iscs = isfc(data, pairwise=False, summary_statistic=None)
assert isfcs.shape == (n_subjects, n_voxels * (n_voxels - 1) / 2)
assert iscs.shape == (n_subjects, n_voxels)
# Without vectorized upper triangle
isfcs = isfc(data, pairwise=False, summary_statistic=None,
vectorize_isfcs=False)
assert isfcs.shape == (n_subjects, n_voxels, n_voxels)
# Just two subjects
isfcs, iscs = isfc(data[..., :2], pairwise=False, summary_statistic=None)
assert isfcs.shape == (n_voxels * (n_voxels - 1) / 2,)
assert iscs.shape == (n_voxels,)
isfcs = isfc(data[..., :2], pairwise=False, summary_statistic=None,
vectorize_isfcs=False)
assert isfcs.shape == (n_voxels, n_voxels)
# ISFC with pairwise approach
isfcs, iscs = isfc(data, pairwise=True, summary_statistic=None)
assert isfcs.shape == (n_subjects * (n_subjects - 1) / 2,
n_voxels * (n_voxels - 1) / 2)
assert iscs.shape == (n_subjects * (n_subjects - 1) / 2,
n_voxels)
isfcs = isfc(data, pairwise=True, summary_statistic=None,
vectorize_isfcs=False)
assert isfcs.shape == (n_subjects * (n_subjects - 1) / 2,
n_voxels, n_voxels)
# ISFC with summary statistics
isfcs, iscs = isfc(data, pairwise=True, summary_statistic='mean')
isfcs, iscs = isfc(data, pairwise=True, summary_statistic='median')
# Check output p-values
data = correlated_timeseries(20, 60, noise=.5,
random_state=42)
isfcs = isfc(data, pairwise=False, vectorize_isfcs=False)
assert np.all(isfcs[:, 0, 1] > .5) and np.all(isfcs[:, 1, 0] > .5)
assert np.all(isfcs[:, :2, 2] < .5) and np.all(isfcs[:, 2, :2] < .5)
isfcs = isfc(data, pairwise=True, vectorize_isfcs=False)
assert np.all(isfcs[:, 0, 1] > .5) and np.all(isfcs[:, 1, 0] > .5)
assert np.all(isfcs[:, :2, 2] < .5) and np.all(isfcs[:, 2, :2] < .5)
# Check that ISC and ISFC diagonal are identical
iscs = isc(data, pairwise=False)
isfcs = isfc(data, pairwise=False, vectorize_isfcs=False)
for s in np.arange(len(iscs)):
assert np.allclose(isfcs[s, ...].diagonal(), iscs[s, :], rtol=1e-03)
isfcs, iscs_v = isfc(data, pairwise=False)
assert np.allclose(iscs, iscs_v, rtol=1e-03)
# Check that ISC and ISFC diagonal are identical (pairwise)
iscs = isc(data, pairwise=True)
isfcs = isfc(data, pairwise=True, vectorize_isfcs=False)
for s in np.arange(len(iscs)):
assert np.allclose(isfcs[s, ...].diagonal(), iscs[s, :], rtol=1e-03)
isfcs, iscs_v = isfc(data, pairwise=True)
assert np.allclose(iscs, iscs_v, rtol=1e-03)
logger.info("Finished testing ISFC options")
def test_permutation_isc():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
random_state = 42
group_assignment = [1] * 10 + [2] * 10
logger.info("Testing permutation test")
# Create dataset with two groups in pairwise approach
data = np.dstack((simulated_timeseries(10, n_TRs, n_voxels=n_voxels,
noise=1, data_type='array',
random_state=3),
simulated_timeseries(10, n_TRs, n_voxels=n_voxels,
noise=5, data_type='array',
random_state=4)))
iscs = isc(data, pairwise=True, summary_statistic=None)
observed, p, distribution = permutation_isc(
iscs,
group_assignment=group_assignment,
pairwise=True,
summary_statistic='mean',
n_permutations=200)
# Create data with two groups in leave-one-out approach
data_1 = simulated_timeseries(10, n_TRs, n_voxels=n_voxels,
noise=1, data_type='array',
random_state=3)
data_2 = simulated_timeseries(10, n_TRs, n_voxels=n_voxels,
noise=10, data_type='array',
random_state=4)
iscs = np.vstack((isc(data_1, pairwise=False, summary_statistic=None),
isc(data_2, pairwise=False, summary_statistic=None)))
observed, p, distribution = permutation_isc(
iscs,
group_assignment=group_assignment,
pairwise=False,
summary_statistic='mean',
n_permutations=200)
# One-sample leave-one-out permutation test
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
iscs = isc(data, pairwise=False, summary_statistic=None)
observed, p, distribution = permutation_isc(iscs,
pairwise=False,
summary_statistic='median',
n_permutations=200)
# One-sample pairwise permutation test
iscs = isc(data, pairwise=True, summary_statistic=None)
observed, p, distribution = permutation_isc(iscs,
pairwise=True,
summary_statistic='median',
n_permutations=200)
# Small one-sample pairwise exact test
data = simulated_timeseries(12, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
iscs = isc(data, pairwise=False, summary_statistic=None)
observed, p, distribution = permutation_isc(iscs, pairwise=False,
summary_statistic='median',
n_permutations=10000)
# Small two-sample pairwise exact test (and unequal groups)
data = np.dstack((simulated_timeseries(3, n_TRs, n_voxels=n_voxels,
noise=1, data_type='array',
random_state=3),
simulated_timeseries(4, n_TRs, n_voxels=n_voxels,
noise=50, data_type='array',
random_state=4)))
iscs = isc(data, pairwise=True, summary_statistic=None)
group_assignment = [1, 1, 1, 2, 2, 2, 2]
observed, p, distribution = permutation_isc(
iscs,
group_assignment=group_assignment,
pairwise=True,
summary_statistic='mean',
n_permutations=10000)
# Small two-sample leave-one-out exact test (and unequal groups)
data_1 = simulated_timeseries(3, n_TRs, n_voxels=n_voxels,
noise=1, data_type='array',
random_state=3)
data_2 = simulated_timeseries(4, n_TRs, n_voxels=n_voxels,
noise=50, data_type='array',
random_state=4)
iscs = np.vstack((isc(data_1, pairwise=False, summary_statistic=None),
isc(data_2, pairwise=False, summary_statistic=None)))
group_assignment = [1, 1, 1, 2, 2, 2, 2]
observed, p, distribution = permutation_isc(
iscs,
group_assignment=group_assignment,
pairwise=False,
summary_statistic='mean',
n_permutations=10000)
# Check output p-values
data = correlated_timeseries(20, 60, noise=.5,
random_state=42)
iscs = isc(data, pairwise=False)
observed, p, distribution = permutation_isc(iscs, pairwise=False)
assert np.all(iscs[:, :2] > .5)
assert np.all(iscs[:, -1] < .5)
assert p[0] < .05 and p[1] < .05
assert p[2] > .01
iscs = isc(data, pairwise=True)
observed, p, distribution = permutation_isc(iscs, pairwise=True)
assert np.all(iscs[:, :2] > .5)
assert np.all(iscs[:, -1] < .5)
assert p[0] < .05 and p[1] < .05
assert p[2] > .01
# Check that ISC computation and permutation observed are same
iscs = isc(data, pairwise=False)
observed, p, distribution = permutation_isc(iscs, pairwise=False,
summary_statistic='median')
assert np.allclose(observed, isc(data, pairwise=False,
summary_statistic='median'),
rtol=1e-03)
# Check that ISC computation and permuation observed are same
iscs = isc(data, pairwise=True)
observed, p, distribution = permutation_isc(iscs, pairwise=True,
summary_statistic='mean')
assert np.allclose(observed, isc(data, pairwise=True,
summary_statistic='mean'),
rtol=1e-03)
logger.info("Finished testing permutaton test")
def test_bootstrap_isc():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
random_state = 42
n_bootstraps = 10
logger.info("Testing bootstrap hypothesis test")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
iscs = isc(data, pairwise=False, summary_statistic=None)
observed, ci, p, distribution = bootstrap_isc(iscs, pairwise=False,
summary_statistic='median',
n_bootstraps=n_bootstraps,
ci_percentile=95)
assert distribution.shape == (n_bootstraps, n_voxels)
# Test one-sample bootstrap test with pairwise approach
n_bootstraps = 10
iscs = isc(data, pairwise=True, summary_statistic=None)
observed, ci, p, distribution = bootstrap_isc(iscs, pairwise=True,
summary_statistic='median',
n_bootstraps=n_bootstraps,
ci_percentile=95)
assert distribution.shape == (n_bootstraps, n_voxels)
# Check random seeds
iscs = isc(data, pairwise=False, summary_statistic=None)
distributions = []
for random_state in [42, 42, None]:
observed, ci, p, distribution = bootstrap_isc(
iscs, pairwise=False,
summary_statistic='median',
n_bootstraps=n_bootstraps,
ci_percentile=95,
random_state=random_state)
distributions.append(distribution)
assert np.array_equal(distributions[0], distributions[1])
assert not np.array_equal(distributions[1], distributions[2])
# Check output p-values
data = correlated_timeseries(20, 60, noise=.5,
random_state=42)
iscs = isc(data, pairwise=False)
observed, ci, p, distribution = bootstrap_isc(iscs, pairwise=False)
assert np.all(iscs[:, :2] > .5)
assert np.all(iscs[:, -1] < .5)
assert p[0] < .05 and p[1] < .05
assert p[2] > .01
iscs = isc(data, pairwise=True)
observed, ci, p, distribution = bootstrap_isc(iscs, pairwise=True)
assert np.all(iscs[:, :2] > .5)
assert np.all(iscs[:, -1] < .5)
assert p[0] < .05 and p[1] < .05
assert p[2] > .01
# Check that ISC computation and bootstrap observed are same
iscs = isc(data, pairwise=False)
observed, ci, p, distribution = bootstrap_isc(iscs, pairwise=False,
summary_statistic='median')
assert np.array_equal(observed, isc(data, pairwise=False,
summary_statistic='median'))
# Check that ISC computation and bootstrap observed are same
iscs = isc(data, pairwise=True)
observed, ci, p, distribution = bootstrap_isc(iscs, pairwise=True,
summary_statistic='median')
assert np.array_equal(observed, isc(data, pairwise=True,
summary_statistic='median'))
logger.info("Finished testing bootstrap hypothesis test")
def test_isc_nans():
# Set parameters for toy time series data
n_subjects = 20
n_TRs = 60
n_voxels = 30
random_state = 42
logger.info("Testing ISC options")
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
# Inject NaNs into data
data[0, 0, 0] = np.nan
# Don't tolerate NaNs, should lose zeroeth voxel
iscs_loo = isc(data, pairwise=False, tolerate_nans=False)
assert np.sum(np.isnan(iscs_loo)) == n_subjects
# Tolerate all NaNs, only subject with NaNs yields NaN
iscs_loo = isc(data, pairwise=False, tolerate_nans=True)
assert np.sum(np.isnan(iscs_loo)) == 1
# Pairwise approach shouldn't care
iscs_pw_T = isc(data, pairwise=True, tolerate_nans=True)
iscs_pw_F = isc(data, pairwise=True, tolerate_nans=False)
assert np.allclose(iscs_pw_T, iscs_pw_F, equal_nan=True)
assert (np.sum(np.isnan(iscs_pw_T)) ==
np.sum(np.isnan(iscs_pw_F)) ==
n_subjects - 1)
# Set proportion of nans to reject (70% and 90% non-NaN)
data[0, 0, :] = np.nan
data[0, 1, :n_subjects - int(n_subjects * .7)] = np.nan
data[0, 2, :n_subjects - int(n_subjects * .9)] = np.nan
iscs_loo_T = isc(data, pairwise=False, tolerate_nans=True)
iscs_loo_F = isc(data, pairwise=False, tolerate_nans=False)
iscs_loo_95 = isc(data, pairwise=False, tolerate_nans=.95)
iscs_loo_90 = isc(data, pairwise=False, tolerate_nans=.90)
iscs_loo_80 = isc(data, pairwise=False, tolerate_nans=.8)
iscs_loo_70 = isc(data, pairwise=False, tolerate_nans=.7)
iscs_loo_60 = isc(data, pairwise=False, tolerate_nans=.6)
assert (np.sum(np.isnan(iscs_loo_F)) ==
np.sum(np.isnan(iscs_loo_95)) == 60)
assert (np.sum(np.isnan(iscs_loo_80)) ==
np.sum(np.isnan(iscs_loo_90)) == 42)
assert (np.sum(np.isnan(iscs_loo_T)) ==
np.sum(np.isnan(iscs_loo_60)) ==
np.sum(np.isnan(iscs_loo_70)) == 28)
assert np.array_equal(np.sum(np.isnan(iscs_loo_F), axis=0),
np.sum(np.isnan(iscs_loo_95), axis=0))
assert np.array_equal(np.sum(np.isnan(iscs_loo_80), axis=0),
np.sum(np.isnan(iscs_loo_90), axis=0))
assert np.all((np.array_equal(
np.sum(np.isnan(iscs_loo_T), axis=0),
np.sum(np.isnan(iscs_loo_60), axis=0)),
np.array_equal(
np.sum(np.isnan(iscs_loo_T), axis=0),
np.sum(np.isnan(iscs_loo_70), axis=0)),
np.array_equal(
np.sum(np.isnan(iscs_loo_60), axis=0),
np.sum(np.isnan(iscs_loo_70), axis=0))))
data = simulated_timeseries(n_subjects, n_TRs,
n_voxels=n_voxels, data_type='array',
random_state=random_state)
# Make sure voxel with NaNs across all subjects is always removed
data[0, 0, :] = np.nan
iscs_loo_T = isc(data, pairwise=False, tolerate_nans=True)
iscs_loo_F = isc(data, pairwise=False, tolerate_nans=False)
assert np.allclose(iscs_loo_T, iscs_loo_F, equal_nan=True)
assert (np.sum(np.isnan(iscs_loo_T)) ==
np.sum(np.isnan(iscs_loo_F)) ==
n_subjects)
iscs_pw_T = isc(data, pairwise=True, tolerate_nans=True)
iscs_pw_F = isc(data, pairwise=True, tolerate_nans=False)
assert np.allclose(iscs_pw_T, iscs_pw_F, equal_nan=True)
assert (np.sum(np.isnan(iscs_pw_T)) ==
np.sum(np.isnan(iscs_pw_F)) ==
n_subjects * (n_subjects - 1) / 2)
datadir + music_subjs[i] + '/ses-01/func/' + music_subjs[i] +
fn_run2, mask)[3:3218, :])
data = np.vstack((data_run1, data_run2))
## Compute mean signal
mu = data.mean(axis=0)
## Apply highpass data.
data = clean(data,
detrend=True,
standardize=False,
high_pass=high_pass,
t_r=TR)
## Convert to percent signal change.
music_data[:, :, i] = data
music_data_mean = np.mean(music_data, axis=1, keepdims=True)
music_iscs = isc(music_data_mean, pairwise=False)
for i in range(len(no_music_subjs)):
data_run1 = zscore(
apply_mask(
datadir + no_music_subjs[i] + '/ses-01/func/' + no_music_subjs[i] +
fn_run1, mask)[0:3240, :])
data_run2 = zscore(
apply_mask(
datadir + no_music_subjs[i] + '/ses-01/func/' + no_music_subjs[i] +
fn_run2, mask)[3:3218, :])
data = np.vstack((data_run1, data_run2))
## Compute mean signal
mu = data.mean(axis=0)
## Apply highpass data.
data = clean(data,
good.append(timecourses[i])
# In[10]:
# Reverse the axes of the time courses data
bad_courses = np.transpose(bad)
good_courses = np.transpose(good)
# In[11]:
# Calculate median ISC for the "bad" group using pairwise approach
iscs_bad = isc(bad_courses, pairwise = True, summary_statistic = "median")
# In[12]:
# Calculate median ISC for the "good" group using pairwise approach
iscs_good = isc(good_courses, pairwise = True, summary_statistic = "median")
# In[13]:
# Get actual ISC values and the actual observed group difference
print(f"Actual observed group difference in ISC values "
f"= {iscs_bad - iscs_good},"
# Select subject-specific column containing condition labels
subj_col = condition_data.loc[:, subjs[s]]
# Select indices corresponding to current condition
idx = np.where(subj_col == conds[c])[0] + 1
# Initialize structure for storing average run data across subjects
avgRuns = np.empty((nTR, mask_size))
for r in range(len(idx)):
# Load run data
runData = nib.load(datadir + subjs[s] +
'/clean_data/clean_data_run' + str(idx[r]) +
'.nii.gz')
# Mask data
masked_data = apply_mask(runData, mask)
# Average current run into existing data structure
avgRuns += masked_data / len(idx)
# Store average run data for each subject separately
data[:, :, s] = avgRuns
# Average over all voxels before feeding to ISC
avgData = np.mean(data, axis=1, keepdims=True)
# Run ISC!!!
iscs = isc(avgData, pairwise=False)
# Save ISCs
np.save(save_dir + conds[c] + '_iscs_' + group, iscs)
#Remove 3rd (singleton) dim and save individual time series
avgData_tosave = np.squeeze(avgData)
np.savetxt(save_dir + conds[c] + '_avgData_' + group + '.txt',
avgData_tosave,
delimiter=',')
np.save(save_dir + conds[c] + '_avgData_' + group, avgData_tosave)
'Allegro_Moderato', 'Finlandia', 'Early_Summer', 'Capriccio_Espagnole',
'Symphony_Fantastique', 'Boogie_Stop_Shuffle', 'My_Favorite_Things',
'Blue_Monk', 'All_Blues'
]
datadir = '/jukebox/norman/jamalw/MES/data/single_song_niftis/'
version = 'avg'
song_idx = int(sys.argv[1])
TRs = nib.load(datadir + songs[song_idx] + '/' + version +
'/subj1.nii.gz').get_data().shape[3]
fn = glob.glob(datadir + songs[song_idx] + '/' + version + '/*')
data = np.empty((91 * 109 * 91, TRs, len(fn)))
# Structure data for brainiak isc function
for i in range(len(fn)):
subj = nib.load(fn[i]).get_data()
subj_reshape = np.reshape(subj, (91 * 109 * 91, TRs))
data[:, :, i] = subj_reshape
print('stored subj: ', i)
iscs = isc(data, pairwise=False, summary_statistic='mean')
print('Saving ISC Results')
save_dir = datadir + songs[song_idx] + '/analysis_results/'
np.save(save_dir + version + '_isc', iscs)
group_assignment.append(train["final_score_binned"][i])
# In[6]:
# Reverse the axes of the time courses data
data = np.transpose(timecourses)
# In[7]:
# Check shape of the data
np.shape(data)
# In[8]:
# Compute ISC summary statistic "median" using pairwise approach
iscs_median = isc(data, pairwise=True, summary_statistic="median")
print(iscs_median)
# In[9]:
# Compute ISCs (pairwise approach) and then run two-sample permutation test on ISCs
iscs = isc(data, pairwise=True, summary_statistic=None)
observed, p, distribution = permutation_isc(
iscs,
group_assignment=group_assignment,
pairwise=True,
summary_statistic='median',
n_permutations=1000,
)
# In[10]:
