def srm(run1, run2):
# initialize model
print('Building Models')
n_iter = 50
srm_k = 30
srm_train_run1 = SRM(n_iter=n_iter, features=srm_k)
srm_train_run2 = SRM(n_iter=n_iter, features=srm_k)
# fit model to training data
print('Training Models')
srm_train_run1.fit(run1)
srm_train_run2.fit(run2)
print('Testing Models')
shared_data_run1 = stats.zscore(np.dstack(srm_train_run2.transform(run1)),
axis=1,
ddof=1)
shared_data_run2 = stats.zscore(np.dstack(srm_train_run1.transform(run2)),
axis=1,
ddof=1)
# average test data across subjects
run1 = np.mean(shared_data_run1, axis=2)
run2 = np.mean(shared_data_run2, axis=2)
return run1, run2
def corr2_coeff(A,msk,myrad,bcast_var):
#if not np.all(msk):
# return None
print('Assigning Masked Data')
run1 = [A[i][msk==1] for i in np.arange(0, int(len(A)/2))]
run2 = [A[i][msk==1] for i in np.arange(int(len(A)/2), len(A))]
print('Building Model')
srm = SRM(bcast_var[0],bcast_var[1])
print('Training Model')
srm.fit(run1)
print('Testing Model')
shared_data = srm.transform(run2)
shared_data = stats.zscore(np.dstack(shared_data),axis=1,ddof=1)
others = np.mean(shared_data[:,:,np.arange(shared_data.shape[-1]) != loo_idx],axis=2)
loo = shared_data[:,:,loo_idx]
corrAB = np.corrcoef(loo.T,others.T)[16:,:16]
corr_eye = np.identity(16)
same_songs = corrAB[corr_eye == 1]
diff_songs = corrAB[corr_eye == 0]
avg_same_songs = np.mean(same_songs)
avg_diff_songs = np.mean(diff_songs)
same_song_minus_diff_song = avg_same_songs - avg_diff_songs
# Compute difference score for permuted matrices
np.random.seed(0)
diff_perm_holder = np.zeros((1000,1))
for i in range(1000):
corrAB_perm = corrAB[np.random.permutation(16),:]
same_songs_perm = corrAB_perm[corr_eye == 1]
diff_songs_perm = corrAB_perm[corr_eye == 0]
diff_perm_holder[i] = np.mean(same_songs_perm) - np.mean(diff_songs_perm)
z = (same_song_minus_diff_song - np.mean(diff_perm_holder))/np.std(diff_perm_holder)
return z
def SRM_V3(run1, run2, srm_k, n_iter):
# initialize model
print('Building Models')
n_iter = n_iter
srm_k = srm_k
srm_train = SRM(n_iter=n_iter, features=srm_k)
# concatenate run1 and run2 within subject before fitting SRM
runs = []
for i in range(len(run1)):
runs.append(np.concatenate((run1[i], run2[i]), axis=1))
# fit model to training data
print('Training Models')
srm_train.fit(runs)
print('Testing Models')
shared_data_run1 = srm_train.transform(run1)
shared_data_run2 = srm_train.transform(run2)
# average test data across subjects
run1 = sum(shared_data_run1) / len(shared_data_run1)
run2 = sum(shared_data_run2) / len(shared_data_run2)
return run1, run2
def fit_srm(data_train, data_test, n_components):
"""Fit the shared response model
Parameters
----------
n_components: k
data_train: 3d array (n_subj, n_features, n_examples/tps)
data_test: 3d array (n_subj, n_features, n_examples/tps)
Returns
-------
data_train_sr: 3d array (n_subj, n_components, n_examples/tps)
the transformed training set
data_test_sr: 3d array (n_subj, n_components, n_examples/tps)
the transformed test set
srm: the fitted model
"""
assert len(data_train) == len(data_test)
n_subjects = len(data_train)
# fit SRM on the training set
srm = SRM(features=n_components)
data_train_sr = srm.fit_transform(data_train)
# transform the hidden activity (on the test set) to the shared space
data_test_sr = srm.transform(data_test)
# calculate variance explained
var_exp_train = calc_srm_var_exp(data_train, data_train_sr, srm.w_)
return data_train_sr, data_test_sr, srm, var_exp_train
def sfn(l, msk, myrad, bcast_var):
# Arguments:
# l -- a list of 4D arrays, containing data from a single searchlight
# msk -- a 3D binary array, mask of this searchlight
# myrad -- an integer, sl_rad
# bcast_var -- whatever is broadcasted
# extract training and testing data
train_data = []
test_data = []
d1,d2,d3,ntr = l[0].shape
nvx = d1*d2*d3
for s in l:
train_data.append(np.reshape(s[:,:,:,:int(ntr/2)],(nvx,int(ntr/2))))
test_data.append(np.reshape(s[:,:,:,int(ntr/2):],(nvx,ntr-int(ntr/2))))
# train an srm model
srm = SRM(bcast_var[0],bcast_var[1])
srm.fit(train_data)
# transform test data
shared_data = srm.transform(test_data)
for s in range(len(l)):
shared_data[s] = np.nan_to_num(stats.zscore(shared_data[s],axis=1,ddof=1))
# run experiment
accu = time_segment_matching_accuracy(shared_data)
# return: can also return several values. In that case, the final output will be
# a 3D array of tuples
return np.mean(accu)
def HMM(X,K,loo_idx,song_idx,song_bounds):
"""fit hidden markov model
Fit HMM to average data and cross-validate with leftout subject using within song and between song average correlations
Parameters
----------
A: voxel by time ndarray (2D)
B: voxel by time ndarray (2D)
C: voxel by time ndarray (2D)
D: voxel by time ndarray (2D)
K: # of events for HMM (scalar)
Returns
-------
z: z-score after performing permuted cross-validation analysis
"""
w = 6
srm_k = 45
nPerm = 1000
within_across = np.zeros(nPerm+1)
run1 = [X[i] for i in np.arange(0, int(len(X)/2))]
run2 = [X[i] for i in np.arange(int(len(X)/2), len(X))]
print('Building Model')
srm = SRM(n_iter=10, features=srm_k)
print('Training Model')
srm.fit(run1)
print('Testing Model')
shared_data = srm.transform(run2)
shared_data = stats.zscore(np.dstack(shared_data),axis=1,ddof=1)
others = np.mean(shared_data[:,:,np.arange(shared_data.shape[-1]) != loo_idx],axis=2)
loo = shared_data[:,song_bounds[song_idx]:song_bounds[song_idx + 1],loo_idx]
nTR = loo.shape[1]
# Fit to all but one subject
ev = brainiak.eventseg.event.EventSegment(K)
ev.fit(others[:,song_bounds[song_idx]:song_bounds[song_idx + 1]].T)
events = np.argmax(ev.segments_[0],axis=1)
# Compute correlations separated by w in time
corrs = np.zeros(nTR-w)
for t in range(nTR-w):
corrs[t] = pearsonr(loo[:,t],loo[:,t+w])[0]
# Compute within vs across boundary correlations, for real and permuted bounds
for p in range(nPerm+1):
within = corrs[events[:-w] == events[w:]].mean()
across = corrs[events[:-w] != events[w:]].mean()
within_across[p] = within - across
np.random.seed(p)
events = np.zeros(nTR, dtype=np.int)
events[np.random.choice(nTR,K-1,replace=False)] = 1
events = np.cumsum(events)
return within_across
def HMM(X, human_bounds, song_idx, song_bounds, srm_k, hrf):
"""fit hidden markov model
Fit HMM to average data and cross-validate with leftout subject using within song and between song average correlations
Parameters
----------
A: voxel by time ndarray (2D)
B: voxel by time ndarray (2D)
C: voxel by time ndarray (2D)
D: voxel by time ndarray (2D)
K: # of events for HMM (scalar)
Returns
-------
z: z-score after performing permuted cross-validation analysis
"""
w = 3
nPerm = 1000
run1 = [X[i] for i in np.arange(0, int(len(X) / 2))]
run2 = [X[i] for i in np.arange(int(len(X) / 2), len(X))]
print('Building Model')
srm = SRM(n_iter=10, features=srm_k)
print('Training Model')
srm.fit(run2)
print('Testing Model')
shared_data = srm.transform(run1)
shared_data = stats.zscore(np.dstack(shared_data), axis=1, ddof=1)
data = np.mean(shared_data[:, song_bounds[song_idx]:song_bounds[song_idx +
1]],
axis=2)
nTR = data.shape[1]
# Fit to all but one subject
K = len(human_bounds) + 1
ev = brainiak.eventseg.event.EventSegment(K)
ev.fit(data.T)
bounds = np.where(np.diff(np.argmax(ev.segments_[0], axis=1)))[0] + 1
match = np.zeros(nPerm + 1)
events = np.argmax(ev.segments_[0], axis=1)
_, event_lengths = np.unique(events, return_counts=True)
perm_bounds = bounds.copy()
for p in range(nPerm + 1):
for hb in human_bounds:
if np.any(np.abs(perm_bounds - hb) <= w):
match[p] += 1
match[p] /= len(human_bounds)
np.random.seed(p)
perm_bounds = np.cumsum(np.random.permutation(event_lengths))[:-1]
return match
def SRM_V2(run1, run2, srm_k, n_iter):
# initialize model
print('Building Models')
n_iter = n_iter
srm_k = srm_k
srm_train_run1 = SRM(n_iter=n_iter, features=srm_k)
srm_train_run2 = SRM(n_iter=n_iter, features=srm_k)
# fit model to training data
print('Training Models')
srm_train_run1.fit(run1)
srm_train_run2.fit(run2)
print('Testing Models')
shared_data_run1 = srm_train_run2.transform(run1)
shared_data_run2 = srm_train_run1.transform(run2)
# average test data across subjects
run1 = sum(shared_data_run1) / len(shared_data_run1)
run2 = sum(shared_data_run2) / len(shared_data_run2)
return run1, run2
def SRM_V1(train, test, srm_k, n_iter):
# initialize model
print('Building Models')
srm_train_data = SRM(n_iter=n_iter, features=srm_k)
# fit model to training data
print('Training Models')
srm_train_data.fit(train)
print('Testing Models')
shared_data = srm_train_data.transform(test)
return shared_data
def srm(train_data, test_data, n_features):
# Z-score the data
n = len(train_data)
for subject in range(n):
train_data[subject] = stats.zscore(train_data[subject], axis=1, ddof=1)
test_data[subject] = stats.zscore(test_data[subject], axis=1, ddof=1)
model = SRM(n_iter=10, features=n_features)
model.fit(train_data)
projected_data = model.transform(test_data)
for subject in range(n):
projected_data[subject] = stats.zscore(projected_data[subject], axis=1, ddof=1)
return projected_data
def isc_srm(X,set_srm):
"""perform isc on srm searchlights
Parameters
----------
X: list of searchlights where searchlights are voxels by time
Returns
-------
r: correlations for each searchlights timecourse correlated with all other timecourses
"""
run1 = [X[i] for i in np.arange(0, int(len(X)/2))]
run2 = [X[i] for i in np.arange(int(len(X)/2), len(X))]
data = np.zeros((run1[0].shape[0],run1[0].shape[1]*2,len(run1)))
if set_srm == 0:
for i in range(data.shape[2]):
data[:,:,i] = np.hstack((run1[i],run2[i]))
# run isc
isc_output = brainiak.isfc.isfc(data)
elif set_srm == 1:
# train on run 1 and test on run 2
print('Building Model')
srm = SRM(n_iter=10, features=5)
print('Training Model')
srm.fit(run1)
print('Testing Model')
shared_data = srm.transform(run2)
shared_data = stats.zscore(np.dstack(shared_data),axis=1,ddof=1)
# run isc
isc_output = brainiak.isfc.isfc(shared_data)
print(isc_output)
# average isc results
mean_isc = np.mean(isc_output)
return mean_isc,isc_output
def sfn(l, msk, myrad, bcast_var):
# extract training and testing data
train_data = []
test_data = []
d1, d2, d3, ntr = l[0].shape
nvx = d1 * d2 * d3
for s in l:
train_data.append(
np.reshape(s[:, :, :, :int(ntr / 2)], (nvx, int(ntr / 2))))
test_data.append(
np.reshape(s[:, :, :, int(ntr / 2):], (nvx, ntr - int(ntr / 2))))
# train an srm model
srm = SRM(bcast_var[0], bcast_var[1])
srm.fit(train_data)
# transform test data
shared_data = srm.transform(test_data)
for s in range(len(l)):
shared_data[s] = np.nan_to_num(
stats.zscore(shared_data[s], axis=1, ddof=1))
# experiment
accu = timesegmentmatching_accuracy(shared_data, 6)
return np.mean(accu), stats.sem(
accu) # multiple outputs will be saved as tuples
n_iter = 50
features = 10
# Initialize model
print('Building Model')
srm_train_run1 = SRM(n_iter=n_iter, features=features)
srm_train_run2 = SRM(n_iter=n_iter, features=features)
# Fit model to training data
print('Training Model')
srm_train_run1.fit(run1_list)
srm_train_run2.fit(run2_list)
# Test model on testing data to produce shared response
print('Testing Model')
shared_data_train_run1 = srm_train_run1.transform(run2_list)
shared_data_train_run2 = srm_train_run2.transform(run1_list)
avg_response_train_run1 = sum(shared_data_train_run1) / len(
shared_data_train_run1)
avg_response_train_run2 = sum(shared_data_train_run2) / len(
shared_data_train_run2)
##################################################################################
for i in range(16):
print('song number ', str(i))
# grab start and end time for each song from bound vectors. for SRM data trained on run 1 and tested on run 2, use song name from run 1 to find index for song onset in run 2 bound vector
start_run1 = song_bounds_run2[songs_run2.index(songs_run1[i])]
end_run1 = song_bounds_run2[songs_run2.index(songs_run1[i]) + 1]
start_run2 = song_bounds_run1[i]
# grab first 4 songs from run 1 to train which is equal to first 628 seconds
for i in subjs:
run1 = datadir + 'subjects/' + i + '/analysis/run1.feat/trans_filtered_func_data.nii'
run2 = datadir + 'subjects/' + i + '/analysis/run2.feat/trans_filtered_func_data.nii'
run1 = nib.load(run1).get_data()[:, :, :, 0:2511]
run2 = nib.load(run2).get_data()[:, :, :, 0:2511]
run2 = run2[mask == 1, :]
train.append(run1[mask == 1, 0:628])
test.append(run2[:, omit_mask == 1])
print('Building Model')
srm = SRM(n_iter=10, features=50)
print('Training Model')
srm.fit(train)
print('Testing Model')
shared_data = srm.transform(test)
shared_data = stats.zscore(np.dstack(shared_data), axis=1, ddof=1)
corrAB_holder = []
correct_songs = np.zeros((25, 12))
for i in range(len(subjs)):
loo = shared_data[:, :, i]
others = np.mean(shared_data[:, :,
np.arange(shared_data.shape[-1]) != i],
axis=2)
corrAB = np.corrcoef(loo.T, others.T)[12:, :12]
corrAB_holder.append(corrAB)
for j in range(len(corrAB)):
mask2_idx = ma.masked_where(
np.arange(len(corrAB)) != j, np.arange(len(corrAB))).mask
data_tr[cond].append(d_tr_i_s_ - mu_i_s_)
data_te[cond].append(d_te_i_s_ - mu_i_s_)
# fit training set
data_tr_unroll = np.concatenate([data_tr[cond] for cond in all_conds], axis=2)
# organize the data for srm form
data_tr_all_conds = np.moveaxis([data_tr[cond] for cond in all_conds],
source=0,
destination=-1).reshape(n_subjs, nH, -1)
data_te_all_conds = np.moveaxis([data_te[cond] for cond in all_conds],
source=0,
destination=-1).reshape(n_subjs, nH, -1)
srm.fit(data_tr_all_conds)
X_test_srm_ = srm.transform(data_te_all_conds)
X_test_srm_bycond = np.moveaxis(np.reshape(X_test_srm_,
newshape=(n_subjs, dim_srm, -1, 3)),
source=-1,
destination=0)
X_test_srm = {cond: None for cond in all_conds}
for i, cond in enumerate(all_conds):
X_test_srm_cond_ = X_test_srm_bycond[i].reshape(n_subjs, dim_srm, -1,
n_examples_te)
X_test_srm[cond] = np.moveaxis(X_test_srm_cond_, source=-1, destination=0)
'''Inter-subject pattern correlation, RM vs. cond'''
def compute_bs_bc_trsm(data_te_srm_rm_i, data_te_srm_xm_i, return_mean=True):
_, m_, n_ = np.shape(data_te_srm_rm_i)
train_roi[story] = np.nan_to_num(zscore(roi_data, axis=0))
# Time-series SRM on ROI data
if timeseries_srm:
test_shared = {}
for story in stories:
srm = SRM(n_iter=n_iter, features=n_features)
# Change subjects to list for SRM
train_list = [train.T for train in np.moveaxis(train_roi[story], 2, 0)]
test_list = [test.T for test in np.moveaxis(test_roi[story], 2, 0)]
# Train SRM and apply
srm.fit(train_list)
test_transformed = srm.transform(test_list)
test_shared[story] = np.dstack([test.T for test in test_transformed])
# Load in the whole-brain surface data
train_target, test_target = {}, {}
for story in train_stories:
# Stack left and right hemispheres
target_data = np.hstack((np.load(f'{story}_cortex_lh_data.npy'),
np.load(f'{story}_cortex_lh_data.npy')))
# Remove zeroed vertices (medial wall)
target_data = target_data[:, ~np.all(target_data == 0, axis=(0, 2))]
# Split targets into training and test sets
target_trs = target_data.shape[0]
def HMM(X, human_bounds, song_idx, song_bounds, hrf, srm_k):
"""fit hidden markov model
Fit HMM to average data and cross-validate with leftout subjects using within song and between song average correlations
Parameters
----------
A: list of 50 (contains 2 runs per subject) 2D (voxels x full time course) arrays
B: # of events for HMM (scalar)
song_idx: song index (scalar)
C: voxel by time ndarray (2D)
D: array of song boundaries (1D)
Returns
-------
wVa score: final score after performing cross-validation of leftout subjects
"""
w = 6
nPerm = 1000
within_across = np.zeros(nPerm + 1)
run1 = [X[i] for i in np.arange(0, int(len(X) / 2))]
run2 = [X[i] for i in np.arange(int(len(X) / 2), len(X))]
print('Building Model')
srm = SRM(n_iter=10, features=srm_k)
print('Training Model')
srm.fit(run1)
print('Testing Model')
shared_data = srm.transform(run2)
shared_data = stats.zscore(np.dstack(shared_data), axis=1, ddof=1)
others = np.mean(
shared_data[:, song_bounds[song_idx]:song_bounds[song_idx + 1], :13],
axis=2)
loo = np.mean(shared_data[:,
song_bounds[song_idx]:song_bounds[song_idx + 1],
13:],
axis=2)
nTR = loo.shape[1]
# Fit to all but one subject
K = len(human_bounds) + 1
ev = brainiak.eventseg.event.EventSegment(K)
ev.fit(others.T)
events = np.argmax(ev.segments_[0], axis=1)
# Compute correlations separated by w in time
corrs = np.zeros(nTR - w)
for t in range(nTR - w):
corrs[t] = pearsonr(loo[:, t], loo[:, t + w])[0]
# Compute within vs across boundary correlations, for real and permuted bounds
for p in range(nPerm + 1):
within = corrs[events[:-w] == events[w:]].mean()
across = corrs[events[:-w] != events[w:]].mean()
within_across[p] = within - across
np.random.seed(p)
events = np.zeros(nTR, dtype=np.int)
events[np.random.choice(nTR, K - 1, replace=False)] = 1
events = np.cumsum(events)
print((within_across[0] - np.mean(within_across[1:])) /
np.std(within_across[1:]))
return within_across
test_list_roi_2.append(test_roi_2[:,:,i])
# Initialize models
print('Building Model')
srm_roi_1 = SRM(n_iter=50, features=5)
srm_roi_2 = SRM(n_iter=50, features=5)
# Fit model to training data (run 1)
print('Training Model')
srm_roi_1.fit(train_list_roi_1)
srm_roi_2.fit(train_list_roi_2)
# Test model on testing data to produce shared response
print('Testing Model')
shared_data_roi_1 = srm_roi_1.transform(test_list_roi_1)
shared_data_roi_2 = srm_roi_2.transform(test_list_roi_2)
avg_response_roi_1 = sum(shared_data_roi_1)/len(shared_data_roi_1)
avg_response_roi_2 = sum(shared_data_roi_2)/len(shared_data_roi_2)
# Fit to ROI 1
ev1 = brainiak.eventseg.event.EventSegment(len(human_bounds) - 1)
ev1.fit(avg_response_roi_1[:,start:end].T)
bounds1 = np.where(np.diff(np.argmax(ev1.segments_[0], axis=1)))[0]
# Fit to ROI 2
ev2 = brainiak.eventseg.event.EventSegment(len(human_bounds) - 1)
ev2.fit(avg_response_roi_2[:,start:end].T)
train_list_vmPFC.append(train_vmPFC[:, :, i])
test_list_vmPFC.append(test_vmPFC[:, :, i])
# Initialize models
print('Building Model')
srm_A1 = SRM(n_iter=10, features=50)
srm_vmPFC = SRM(n_iter=10, features=10)
# Fit model to training data (run 1)
print('Training Model')
srm_A1.fit(train_list_A1)
srm_vmPFC.fit(train_list_vmPFC)
# Test model on testing data to produce shared response
print('Testing Model')
shared_data_A1 = srm_A1.transform(test_list_A1)
shared_data_vmPFC = srm_vmPFC.transform(test_list_vmPFC)
avg_response_A1 = sum(shared_data_A1) / len(shared_data_A1)
avg_response_vmPFC = sum(shared_data_vmPFC) / len(shared_data_vmPFC)
A1_no_srm = np.mean(test_A1, axis=2)
vmPFC_no_srm = np.mean(test_vmPFC, axis=2)
X_MIN = 0
X_MAX = spect_corr.shape[0]
Y_MIN = spect_corr.shape[0]
Y_MAX = 0
X_VALS = range(X_MIN, X_MAX)
fig, ((ax1, ax2, ax3, ax4), (ax5, ax6, ax7, ax8)) = plt.subplots(2, 4)
def HMM(X, K, loo_idx, song_idx, song_bounds):
"""fit hidden markov model
Fit HMM to average data and cross-validate with leftout subject using within song and between song average correlations
Parameters
----------
A: voxel by time ndarray (2D)
B: voxel by time ndarray (2D)
C: voxel by time ndarray (2D)
D: voxel by time ndarray (2D)
K: # of events for HMM (scalar)
Returns
-------
z: z-score after performing permuted cross-validation analysis
"""
w = 6
srm_k = 45
nPerm = 1000
within_across = np.zeros(nPerm + 1)
run1 = [X[i] for i in np.arange(0, int(len(X) / 2))]
run2 = [X[i] for i in np.arange(int(len(X) / 2), len(X))]
print('Building Model')
srm = SRM(n_iter=10, features=srm_k)
print('Training Model')
srm.fit(run1)
print('Testing Model')
shared_data = srm.transform(run2)
shared_data = stats.zscore(np.dstack(shared_data), axis=1, ddof=1)
others = np.mean(shared_data[:, :,
np.arange(shared_data.shape[-1]) != loo_idx],
axis=2)
loo = shared_data[:, song_bounds[song_idx]:song_bounds[song_idx + 1],
loo_idx]
nTR = loo.shape[1]
# Fit to all but one subject
ev = brainiak.eventseg.event.EventSegment(K)
ev.fit(others[:, song_bounds[song_idx]:song_bounds[song_idx + 1]].T)
events = np.argmax(ev.segments_[0], axis=1)
####
# plot searchlights
import matplotlib.pyplot as plt
import matplotlib.patches as patches
shared_data = srm.transform(run2)
avg_response = sum(shared_data) / len(shared_data)
plt.figure(figsize=(10, 10))
plt.imshow(np.corrcoef(avg_response[:, 0:89].T))
bounds = np.where(np.diff(np.argmax(ev.segments_[0], axis=1)))[0]
ax = plt.gca()
bounds_aug = np.concatenate(([0], bounds, [nTR]))
for i in range(len(bounds_aug) - 1):
rect1 = patches.Rectangle((bounds_aug[i], bounds_aug[i]),
bounds_aug[i + 1] - bounds_aug[i],
bounds_aug[i + 1] - bounds_aug[i],
linewidth=3,
edgecolor='w',
facecolor='none',
label='Model Fit')
ax.add_patch(rect1)
plt.title('HMM Fit to A1 SRM K = ' + str(srm_k),
fontsize=18,
fontweight='bold')
plt.savefig('plots/St_Pauls SRM K = ' + str(srm_k))
####
# Compute correlations separated by w in time
corrs = np.zeros(nTR - w)
for t in range(nTR - w):
corrs[t] = pearsonr(loo[:, t], loo[:, t + w])[0]
# Compute within vs across boundary correlations, for real and permuted bounds
for p in range(nPerm + 1):
within = corrs[events[:-w] == events[w:]].mean()
across = corrs[events[:-w] != events[w:]].mean()
within_across[p] = within - across
np.random.seed(p)
events = np.zeros(nTR, dtype=np.int)
events[np.random.choice(nTR, K - 1, replace=False)] = 1
events = np.cumsum(events)
return within_across