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