def pair_dist(rand_pair, sub_files, sub_data=[], reg_var=[], len_time=235, data_field='dtseries'): """ Pair distance """ sub_data = np.array(sub_data) if sub_data.size > 0: sub1_data = sub_data[:, :, rand_pair[0]] sub2_data = sub_data[:, :, rand_pair[1]] else: sub1_data = spio.loadmat(sub_files[rand_pair[0]])[data_field].T sub2_data = spio.loadmat(sub_files[rand_pair[1]])[data_field].T sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) sub2_data, _ = brainSync(X=sub1_data, Y=sub2_data) fmri_diff = sp.sum((sub2_data - sub1_data)**2, axis=0) # Returns SQUARE of the distance if len(reg_var) > 0: regvar_diff = sp.square(reg_var[rand_pair[0]] - reg_var[rand_pair[1]]) return fmri_diff, regvar_diff else: return fmri_diff
def pair_dist_two_groups(rand_pair, sub_grp1_files, sub_grp2_files, sub_data1=[], sub_data2=[], len_time=235): sub_data1 = np.array(sub_data1) sub_data2 = np.array(sub_data2) """ Pair distance for two groups of subjects """ if sub_data1.size > 0: sub1_data = sub_data1[:, :, rand_pair[0]] else: sub1_data = spio.loadmat(sub_grp1_files[rand_pair[0]])['dtseries'].T sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) if sub_data2.size > 0: sub2_data = sub_data2[:, :, rand_pair[1]] else: sub2_data = spio.loadmat(sub_grp2_files[rand_pair[1]])['dtseries'].T sub2_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _ = brainSync(X=sub1_data, Y=sub2_data) fmri_diff = sp.sum((sub2_data - sub1_data)**2, axis=0) # Returns SQUARE of the distance return fmri_diff
def dist2atlas_reg(bfp_path, ref_atlas, sub_files, reg_var, len_time=235): """ Perform regression stats based on square distance to atlas """ print('dist2atlas_reg, assume that the data is normalized') num_vert = ref_atlas.shape[1] num_sub = len(sub_files) # Take absolute value of difference from the mean # for the IQ measure reg_var = sp.absolute(reg_var - sp.mean(reg_var)) diff = sp.zeros((num_vert, num_sub)) # Compute distance to atlas for ind in tqdm(range(num_sub)): sub_data = spio.loadmat(sub_files[ind])['dtseries'].T sub_data, _, _ = normalizeData(sub_data[:len_time, :]) Y2, _ = brainSync(X=ref_atlas, Y=sub_data) diff[:, ind] = sp.sum((Y2 - ref_atlas)**2, axis=0) corr_pval = sp.zeros(num_vert) for vrt in tqdm(range(num_vert)): _, corr_pval[vrt] = sp.stats.pearsonr(diff[vrt, :], reg_var) corr_pval[sp.isnan(corr_pval)] = .5 lab = spio.loadmat(bfp_path + '/supp_data/USCBrain_grayord_labels.mat') labs = lab['labels'].squeeze() corr_pval_fdr = sp.zeros(num_vert) _, pv = fdrcorrection(corr_pval[labs > 0]) corr_pval_fdr[labs > 0] = pv return corr_pval, corr_pval_fdr
def sync2atlas(atlas, sub_data): print('Syncing to atlas, assume that the data is normalized') # Assume that the sub_data is already normalized syn_data = sp.zeros(sub_data.shape) for ind in tqdm(range(sub_data.shape[2])): syn_data[:, :, ind], _ = brainSync(X=atlas, Y=sub_data[:, :, ind]) return syn_data
def pairsdist_regression(bfp_path, sub_files, reg_var, num_perm=1000, num_pairs=0, len_time=235): """ Perform regression stats based on square distance between random pairs """ # Get the number of vertices from a file num_vert = spio.loadmat(sub_files[0])['dtseries'].shape[0] num_sub = len(sub_files) # Allocate memory for subject data sub_data = np.zeros(shape=(len_time, num_vert, num_sub)) # Generate random pairs print('Reading subjects') for subno, filename in enumerate(tqdm(sub_files)): data = spio.loadmat(filename)['dtseries'].T sub_data[:, :, subno], _, _ = normalizeData(data[:len_time, :]) pairs = list(itertools.combinations(range(num_sub), r=2)) if num_pairs > 0: rn = np.random.permutation(len(pairs)) pairs = [pairs[i] for i in rn] pairs = pairs[:num_pairs] fmri_diff = sp.zeros((num_vert, len(pairs))) regvar_diff = sp.zeros(len(pairs)) print('Computing pairwise differences') for pn, pair in enumerate(tqdm(pairs)): Y2, _ = brainSync(X=sub_data[:, :, pair[0]], Y=sub_data[:, :, pair[1]]) fmri_diff[:, pn] = np.sum((Y2 - sub_data[:, :, pair[0]])**2, axis=0) regvar_diff[pn] = (reg_var[pair[0]] - reg_var[pair[1]])**2 corr_pval = corr_perm_test(X=fmri_diff.T, Y=regvar_diff) # corr_pval = sp.zeros(num_vert) # for ind in tqdm(range(num_vert)): # _, corr_pval[ind] = sp.stats.pearsonr(fmri_diff[ind, :], regvar_diff) # corr_pval[sp.isnan(corr_pval)] = .5 # labs = spio.loadmat( bfp_path + '/supp_data/USCBrain_grayordinate_labels.mat')['labels'].squeeze() labs[sp.isnan(labs)] = 0 corr_pval[labs == 0] = 0.5 corr_pval_fdr = 0.5 * sp.ones(num_vert) _, corr_pval_fdr[labs > 0] = fdrcorrection(corr_pval[labs > 0]) return corr_pval, corr_pval_fdr
def lin_reg(bfp_path, ref_atlas, sub_files, reg_var, Vndim=235, Sndim=20, len_time=235): """ Perform regression stats based on distance to atlas """ num_vert = ref_atlas.shape[1] num_sub = len(sub_files) a = spio.loadmat(bfp_path + '/supp_data/USCBrain_grayord_labels.mat') labs = a['labels'].squeeze() labs[sp.isnan(labs)] = 0 print('Computing PCA basis function from the atlas') pca = PCA(n_components=Vndim) pca.fit(ref_atlas.T) reduced_data = sp.zeros((Vndim, num_vert, num_sub)) for ind in tqdm(range(num_sub)): sub_data = spio.loadmat(sub_files[ind])['dtseries'].T sub_data, _, _ = normalizeData(sub_data[:len_time, :]) Y2, _ = brainSync(X=ref_atlas, Y=sub_data) if Vndim == len_time: reduced_data[:, :, ind] = sub_data else: reduced_data[:, :, ind] = pca.transform(Y2.T).T pval_linreg = sp.zeros(num_vert) pca = PCA(n_components=Sndim) for vrt in tqdm(range(num_vert)): X = reduced_data[:, vrt, :] if Sndim != num_sub: pca.fit(X.T) X = pca.transform(X.T).T X = sm.add_constant(X.T) est = sm.OLS(reg_var, X) pval_linreg[vrt] = est.fit().f_pvalue print('Regression is done') pval_linreg[sp.isnan(pval_linreg)] = .5 pval_linreg_fdr = sp.zeros(num_vert) _, pv = fdrcorrection(pval_linreg[labs > 0]) pval_linreg_fdr[labs > 0] = pv return pval_linreg, pval_linreg_fdr
def pair_dist(rand_pair, sub_files, reg_var, len_time=235): """ Pair distance """ sub1_data = spio.loadmat(sub_files[rand_pair[0]])['dtseries'].T sub2_data = spio.loadmat(sub_files[rand_pair[1]])['dtseries'].T sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) sub2_data, _ = brainSync(X=sub1_data, Y=sub2_data) fmri_diff = sp.sum((sub2_data - sub1_data)**2, axis=0) regvar_diff = sp.square(reg_var[rand_pair[0]] - reg_var[rand_pair[1]]) return fmri_diff, regvar_diff
def sub2ctrl_dist(sub_file, ctrl_files, len_time=235): """ Compare a subject to controls """ sub_data = spio.loadmat(sub_file)['dtseries'].T sub_data, _, _ = normalizeData(sub_data[:len_time, :]) num_vert = sub_data.shape[1] fmri_diff = sp.zeros((num_vert, len(ctrl_files))) for ind, fname in enumerate(tqdm(ctrl_files)): ctrl_data = spio.loadmat(fname)['dtseries'].T ctrl_data, _, _ = normalizeData(ctrl_data[:len_time, :]) ctrl_data, _ = brainSync(X=sub_data, Y=ctrl_data) fmri_diff[:, ind] = sp.sum((sub_data - ctrl_data)**2, axis=0) return fmri_diff
def randpairsdist_reg(bfp_path, sub_files, reg_var, num_pairs=1000, len_time=235): """ Perform regression stats based on square distance between random pairs """ print('dist2atlas_reg, assume that the data is normalized') print('This function is deprecated!!!!!!!!!!') # Get the number of vertices from a file num_vert = spio.loadmat(sub_files[0])['dtseries'].shape[0] # Generate random pairs rand_pairs = sp.random.choice(len(sub_files), (num_pairs, 2), replace=True) fmri_diff = sp.zeros((num_vert, num_pairs)) regvar_diff = sp.zeros(num_pairs) print('Reading subjects') # Compute distance to atlas for ind in tqdm(range(num_pairs)): sub1_data = spio.loadmat(sub_files[rand_pairs[ind, 0]])['dtseries'].T sub2_data = spio.loadmat(sub_files[rand_pairs[ind, 1]])['dtseries'].T sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) sub2_data, _ = brainSync(X=sub1_data, Y=sub2_data) fmri_diff[:, ind] = sp.sum((sub2_data - sub1_data)**2, axis=0) regvar_diff[ind] = sp.square(reg_var[rand_pairs[ind, 0]] - reg_var[rand_pairs[ind, 1]]) corr_pval = sp.zeros(num_vert) for ind in tqdm(range(num_vert)): _, corr_pval[ind] = sp.stats.pearsonr(fmri_diff[ind, :], regvar_diff) corr_pval[sp.isnan(corr_pval)] = .5 labs = spio.loadmat(bfp_path + '/supp_data/USCBrain_grayord_labels.mat' )['labels'].squeeze() corr_pval_fdr = sp.zeros(num_vert) _, corr_pval_fdr[labs > 0] = fdrcorrection(corr_pval[labs > 0]) return corr_pval, corr_pval_fdr
def pair_dist_simulation(rand_pair, sub_files, sub_data=[], reg_var=[], len_time=235, roi=[]): """ Pair distance """ # normalize the clinical variable reg_var_norm, _, _ = normalizeData(reg_var) roi_ind, _ = np.where(roi) noise_data = (reg_var_norm - np.min(reg_var_norm)) * np.random.normal( size=(len(roi_ind), len_time, len(reg_var))) sub_data = np.array(sub_data) if sub_data.size > 0: sub1_data = sub_data[:, :, rand_pair[0]] sub2_data = sub_data[:, :, rand_pair[1]] sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) sub1_data += noise_data[:, :, rand_pair[0]] sub2_data += noise_data[:, :, rand_pair[1]] sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) else: sub1_data = spio.loadmat(sub_files[rand_pair[0]])['dtseries'].T sub2_data = spio.loadmat(sub_files[rand_pair[1]])['dtseries'].T sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) sub1_data[:len_time, roi_ind] += noise_data[:, :, rand_pair[0]].T sub2_data[:len_time, roi_ind] += noise_data[:, :, rand_pair[1]].T sub1_data, _, _ = normalizeData(sub1_data[:len_time, :]) sub2_data, _, _ = normalizeData(sub2_data[:len_time, :]) sub2_data, _ = brainSync(X=sub1_data, Y=sub2_data) fmri_diff = sp.sum((sub2_data - sub1_data)**2, axis=0) # Returns SQUARE of the distance if len(reg_var) > 0: regvar_diff = sp.square(reg_var[rand_pair[0]] - reg_var[rand_pair[1]]) return fmri_diff, regvar_diff else: return fmri_diff
def load_bfp_dataT_dist2atlas(sub_fname, atlas_fname, LenTime, matchT): ''' sub_fname: list of filenames of .mat files that contains Time x Vertex matrix of subjects' preprocessed fMRI data ''' ''' LenTime: number of timepoints in data. this should be the same in all subjects ''' ''' Outputs 3D matrix: Time x Vector x Subjects ''' count1 = 0 subN = len(sub_fname) print('loading data for ' + str(subN) + ' subjects') pbar = tqdm(total=subN) numT = np.zeros(subN) atlas_data = spio.loadmat(atlas_fname) atlas = atlas_data['atlas_data'] subTest_diff = np.zeros((atlas.shape[1], subN)) for ind in range(subN): fname = sub_fname[ind] df = spio.loadmat(fname) data = df['dtseries'].T numT[ind] = data.shape[0] if int(data.shape[0]) != LenTime: if bool(matchT) == True: t = int(LenTime - numT[ind]) v = data.shape[1] temp = np.zeros((t, v)) data = np.concatenate((data, temp)) else: print(sub_fname[ind] + ' does not have the correct number of timepoints') d, _, _ = normalizeData(data) syn_data, _ = brainSync(X=atlas, Y=d) subTest_diff[:, ind], _ = dist2atlas_sub(atlas, syn_data) count1 += 1 pbar.update(1) if count1 == subN: break pbar.close() print('loaded data for ' + str(subN) + ' subjects') return subTest_diff, numT
sub = lst[0] data = scipy.io.loadmat( os.path.join(p_dir, sub, sub + '.rfMRI_REST2_LR.\ reduce3.ftdata.NLM_11N_hvar_25.mat')) LR_flag = msk['LR_flag'] LR_flag = np.squeeze(LR_flag) != 0 data = data['ftdata_NLM'] temp = data[LR_flag, :] d2 = temp.T ind = 0 IntV = range(10, 1200, 10) rms = sp.zeros(len(IntV)) for len1 in IntV: sub_data1, _, _ = normalizeData(d1[:len1, :]) sub_data2, _, _ = normalizeData(d2[:len1, :]) s = sp.std(sub_data2, axis=0) sub_data1 = sub_data1[:, s > 1e-2] sub_data2 = sub_data2[:, s > 1e-2] sub_data2_sync, Rot = brainSync(X=sub_data1, Y=sub_data2) rms[ind] = sp.linalg.norm(sub_data2_sync - sub_data1) / sp.sqrt( sp.linalg.norm(sub_data2_sync)**2 + sp.linalg.norm(sub_data1)**2) ind += 1 print len1, ':', rms[ind - 1] plt.plot(IntV, rms) plt.ylim(ymax=0.7, ymin=0.30) plt.savefig('sync_vs_len_same_sub2.pdf') plt.show()
dat = spio.loadmat('/big_disk/ajoshi/with_andrew/100307/100307.\ rfMRI_REST1_RL.reduce3.ftdata.NLM_11N_hvar_5.mat') fmotor = dat['ftdata_NLM'].T fmotor = fmotor[:284, :] fmotor, _, _ = normalizeData(fmotor) dat = spio.loadmat('/big_disk/ajoshi/with_andrew/100307/100307.\ rfMRI_REST1_LR.reduce3.ftdata.NLM_11N_hvar_5.mat') frest = dat['ftdata_NLM'].T frest = frest[:fmotor.shape[0], :] frest, _, _ = normalizeData(frest) diffbefore = fmotor - frest fmotor, _ = brainSync(frest, fmotor) diffafter = fmotor - frest plt.imshow(sp.absolute(diffbefore), aspect='auto', clim=(0, 0.1)) plt.colorbar() plt.savefig('dist_motor_before.pdf', dpi=300) plt.show() plt.figure() plt.imshow(sp.absolute(diffafter), aspect='auto', clim=(0, .1)) plt.colorbar() plt.savefig('dist_motor_after.pdf', dpi=300) plt.show() #diffafter = gaussian_filter(diffafter, [2, 0]) nV = len(dfs_right_sm.vertices)
elevation=180, roll=90, outfile='sub1to2_view1_pc.png', show=1) view_patch_vtk(dfs_left_sm, azimuth=-90, elevation=-180, roll=-90, outfile='sub1to2_view2_pc.png', show=1) #sm=smooth_patch(dfs_left,iter=1000) #view_patch(sm) #view_patch(dfs_left,rho) sub_rot, R1 = brainSync(X=sub1, Y=sub2) #sub_rot2, R2, C2 = rot_sub_data(sub1.T, sub2.T) #sub_rot=sub_rot.T rho = sp.dot(ref_mean_pc, sub_rot) / ref_mean_pc.shape[0] #rho=rho[0,1:] rho[~np.isfinite(rho)] = 0 #rho = smooth_surf_function(dfs_left_sm, rho) dfs_left.attributes = rho dfs_left_sm = patch_color_attrib(dfs_left_sm, rho, clim=[-1, 1]) view_patch_vtk(dfs_left_sm, azimuth=90, elevation=180, roll=90, outfile='sub1to2_view1_pc_rot.png', show=1) view_patch_vtk(dfs_left_sm,
pbar = tqdm(total=len(subj)) for i in range(len(subj)): print(str(n)) n = n + 1 fname = os.path.join(dirname, subj[i], 'func', subj[i] + ext) if os.path.isfile(fname): df = spio.loadmat(fname) data = df['dtseries'].T if int(data.shape[0]) == LenTime: sub_ID.append(subj[i]) sub_fname.append(fname) pbar.update(1) np.savetxt(out_dir + "/subjects.csv", sub_ID, delimiter=",", fmt='%s') write_text_timestamp( flog, 'data for ' + str(len(sub_ID)) + ' subjects will be used for atlas creation') sub_data = load_bfp_data(sub_fname, LenTime) #%% run group sync groupatlas_data, _, _, _ = groupBrainSync(sub_data) spio.savemat(os.path.join(out_dir + '/group_atlas.mat'), {'groupatlas_data': groupatlas_data}) write_text_timestamp(flog, 'completed group sync') #%% find representative subject subRef_data, q = IDrefsub_BrainSync(sub_data) write_text_timestamp(flog, 'representative subject is ' + str(sub_ID[q])) #%% sync group atlas to representative subject atlas_data, _ = brainSync(subRef_data, groupatlas_data) spio.savemat(os.path.join(out_dir + '/atlas.mat'), {'atlas_data': atlas_data}) write_text_timestamp( flog, 'group atlas synced to representative subject. group-MDS_atlas done.')
data = scipy.io.loadmat( os.path.join( p_dir, sub, sub + '.rfMRI_REST1_LR.\ reduce3.ftdata.NLM_11N_hvar_25.mat')) data = data['ftdata_NLM'] sub1L, _, _ = normalizeData(data[~LR_flag, :].T) sub1R, _, _ = normalizeData(data[LR_flag, :].T) data = scipy.io.loadmat( os.path.join( p_dir, sub, sub + '.rfMRI_REST2_LR.\ reduce3.ftdata.NLM_11N_hvar_25.mat')) data = data['ftdata_NLM'] sub2L, _, _ = normalizeData(data[~LR_flag, :].T) sub2R, _, _ = normalizeData(data[LR_flag, :].T) _, R = brainSync(X=sub1L, Y=sub2L) avgCorrL += sp.sum(sub1L * sp.dot(R, sub2L), axis=0) avgCorrR += sp.sum(sub1R * sp.dot(R, sub2R), axis=0) nSub += 1 print nSub, avgCorrL = avgCorrL / nSub avgCorrR = avgCorrR / nSub # plot correlations in right hemisphere dfs_right_sm = patch_color_attrib(dfs_right_sm, avgCorrR, clim=[0, 1]) view_patch_vtk(dfs_right_sm, azimuth=-90, elevation=-180, roll=-90, outfile='corrLR_right1.png',
vrest_subs[:, :, ind1], _, _ = normalizeData(vrest) # print(ind1, end=' ') print ind1, # %% # Build Null Distribution nVert = vrest_subs.shape[1] rho_null = sp.zeros([nsub, nVert]) for ind1 in range(nsub): t = 0 for ind2 in range(nsub): if ind1 == ind2: continue vrest1 = vrest_subs[:, :, ind1] vrest2 = vrest_subs[:, :, ind2] vrest2, Rot = brainSync(X=vrest1, Y=vrest2) t += sp.sum(vrest1*vrest2, axis=0) rho_null[ind1, :] = t/(nsub-1) print 'rho(%d)=%g' % (ind1, sp.mean(t)) sp.savez('fcon1000_null_nsub50.npz', rho_null=rho_null, vrest_subs=vrest_subs) # %% # Read Candidate Subject to be tested against normals rho_sub = sp.zeros([nsub, nVert]) for ind1 in range(nsub): vrest = vrest_subs[:, :, ind1]
print(count1, ) #%% Compute pairwise distance nSub = count1 sub_data = sub_data[:, :, :nSub] print(nSub) dist_all_orig = sp.zeros([nSub, nSub]) dist_all_rot = dist_all_orig.copy() #sub_data_orig = sub_data.copy() for ind1 in range(nSub): for ind2 in range(nSub): dist_all_orig[ind1, ind2] = sp.linalg.norm(sub_data[:, :, ind1] - sub_data[:, :, ind2]) sub_data_rot, _ = brainSync( X=sub_data[:, :, ind1].T, Y=sub_data[:, :, ind2].T) dist_all_rot[ind1, ind2] = sp.linalg.norm(sub_data[:, :, ind1] - sub_data_rot.T) print(ind1, ind2, dist_all_rot[ind1, ind2]) q = sp.argmin(dist_all_rot.sum(1)) print('The representative subject is: %s ' % lst2[q]) m = MDS(n_components=2, dissimilarity='precomputed') e = m.fit_transform(dist_all_rot) print(e) fig, ax = plt.subplots() ax.scatter(e[:, 0], e[:, 1]) for i in range(e.shape[0]): ax.annotate(lst2[i][30:37], (e[i, 0], e[i, 1])) ax.set_title('MDS Plot of the subjects')
d2, _, _ = normalizeData(temp.T) # d2 = temp sub_data1 = d1.T sub_data2 = d2.T # ind1 = s>1e-10 dist_all_orig = sp.zeros(len(dfs_left_sm.vertices)) # dist_all_rot = dist_all_orig.copy() sub_data_orig1 = sub_data1.copy() sub_data_orig2 = sub_data2.copy() dist_all_orig = sub_data_orig1-sub_data_orig2 sub_data2, _ = brainSync(X=sub_data1.T, Y=sub_data2.T) sub_data2 = sub_data2.T # rot_sub_data(ref=sub_data1, sub=sub_data2) dist_all_rot += sub_data1-sub_data2 print ind, plt.figure() plt.set_cmap('jet') plt.imshow(sp.absolute(dist_all_orig), aspect='auto', clim=(0, 0.1)) plt.colorbar() plt.savefig('dist_before_task.pdf', dpi=300) plt.show() plt.figure() plt.set_cmap('jet') plt.imshow(sp.absolute(dist_all_rot/40), aspect='auto', clim=(0, 0.1))
if count1 == 0: sub_data = sp.zeros((235, d.shape[1], len(normSub))) sub_data[:, :, count1] = d[:235, ] count1 += 1 print(count1, ) if count1 == 50: break #%% Create Average atlas by synchronizing everyones data to one subject atlas = 0 q = 3 nSub = len(normSub) for ind in range(nSub): Y2, _ = brainSync(X=sub_data[:, :, q], Y=sub_data[:, :, ind]) atlas += Y2 atlas /= (nSub) spio.savemat('ADHD_avg_atlas.mat', {'atlas': atlas}) #%% Compute PCA basis using atlas pca = PCA(n_components=NDim) pca.fit(atlas.T) print(pca.explained_variance_ratio_) #%% Read Normal Subjects normSub = normSubOrig[50:135] count1 = 0 for sub in normSub: fname = os.path.join(p_dir, sub + '_rest_bold.32k.GOrd.mat')
p = PCA(n_components=NCMP) D = p.fit_transform(X.T) print("Explained Variance Fraction = %f" % p.explained_variance_ratio_.sum()) # D is the exeplar data D, _, _ = normalizeData(D.T) nT = Xtsk.shape[0] Xnew = np.zeros(Xtsk.shape) Cind = np.int((NCMP - 1) / 2 + 1) for i in range(Xtsk.shape[0] - NCMP): xin = Xtsk[i:i + NCMP, :] xin, _, nrm = normalizeData(xin) dd, _ = brainSync(xin, D) dd = dd * nrm Xnew[Cind + i, :] = dd[Cind, :] print("%d" % i, end=',') #a = nib.cifti2.Cifti2Image(Xnew, sub1.header, file_map=sub1.file_map) #a.to_filename('outfile_task.nii') # #a = nib.cifti2.Cifti2Image(Xtsk-Xnew, sub1.header, file_map=sub1.file_map) #a.to_filename('outfile_diff.nii') #loading cifti files has indices garbled #%% fname1 = 'right_motor1.png' fname2 = 'right_motor2.png'
def load_all_data(studydir, epi_txt, test_epi_txt, nonepi_txt, test_nonepi_txt, atlas_labels): atlas = spio.loadmat(atlas_labels) gord_labels = atlas['labels'].squeeze() # print(len(gord_labels)) # pdb.set_trace() label_ids = np.unique(gord_labels) # unique label ids # remove WM label from connectivity analysis label_ids = np.setdiff1d(label_ids, (2000, 0)) with open(epi_txt) as f: epiIds = f.readlines() with open(nonepi_txt) as f: nonepiIds = f.readlines() epiIds = list(map(lambda x: x.strip(), epiIds)) nonepiIds = list(map(lambda x: x.strip(), nonepiIds)) load_lesion_maps(epiIds, nonepiIds, gord_labels, label_ids) # random.shuffle(epiIds) # random.shuffle(nonepiIds) # print(len(epiIds), epiIds) epi_files = list() nonepi_files = list() for sub in epiIds: fname = os.path.join(studydir, sub, 'BFP', sub, 'func', sub + '_rest_bold.32k.GOrd.mat') if os.path.isfile(fname): epi_files.append(fname) for sub in nonepiIds: fname = os.path.join(studydir, sub, 'BFP', sub, 'func', sub + '_rest_bold.32k.GOrd.mat') if os.path.isfile(fname): nonepi_files.append(fname) epi_data = load_bfp_data(epi_files, 171) nonepi_data = load_bfp_data(nonepi_files, 171) # nsub = epi_data.shape[2] #============================================================== nsub = min(epi_data.shape[2], nonepi_data.shape[2]) epiIds = epiIds[:nsub] nonepiIds = nonepiIds[:nsub] #=============================================================== conn_mat = np.zeros((nsub, len(label_ids), len(label_ids))) cent_mat = np.zeros((nsub, len(label_ids))) input_feat = np.zeros((nsub, len(label_ids), epi_data.shape[0])) print(conn_mat.shape, input_feat.shape) print(epi_data.shape, nonepi_data.shape, gord_labels.shape) _, ref_sub = get_connectivity(nonepi_data[:, :, 0], labels=gord_labels, label_ids=label_ids) for subno in range(nsub): # num of subjects conn_mat[subno, :, :], time_series = get_connectivity(epi_data[:, :, subno], labels=gord_labels, label_ids=label_ids) #G = nx.convert_matrix.from_numpy_array(np.abs(conn_mat[subno, :, :])) #cent = nx.eigenvector_centrality(G, weight='weight') #cent_mat[subno, :] = np.array(list(cent.items()))[:,1] # print(ref_sub.shape, time_series.shape) input_feat[subno, :, :] = np.transpose(brainSync(ref_sub.T, time_series.T)[0]) np.savez('PTE_graphs_gcn_brain.npz', conn_mat=conn_mat, features=input_feat, # 36x16x171 label_ids=label_ids, cent_mat=cent_mat) ##============================================================================ print("non_epi") # nsub = nonepi_data.shape[2] conn_mat = np.zeros((nsub, len(label_ids), len(label_ids))) cent_mat = np.zeros((nsub, len(label_ids))) input_feat = np.zeros((nsub, len(label_ids), nonepi_data.shape[0])) print(conn_mat.shape, input_feat.shape) # here we are using same number of training subjects for epi and nonepi. for subno in range(nsub): conn_mat[subno, :, :], time_series = get_connectivity(nonepi_data[:, :, subno], labels=gord_labels, label_ids=label_ids) #G = nx.convert_matrix.from_numpy_array(np.abs(conn_mat[subno, :, :])) #cent = nx.eigenvector_centrality(G, weight='weight') # cent_mat[subno, :] = np.array(list(cent.items()))[:,1] input_feat[subno, :, :] = np.transpose(brainSync(ref_sub.T, time_series.T)[0]) np.savez('NONPTE_graphs_gcn_brain.npz', conn_mat=conn_mat, # n_subjects*16*16 features=input_feat, # n_subjects * 16 x 171 label_ids=label_ids, cent_mat=cent_mat) print('done')
data = data['ftdata_NLM'] d1, _, _ = normalizeData(data[LR_flag, :].T) data = scipy.io.loadmat( os.path.join(p_dir, sub, sub + '.rfMRI_REST2_LR.\ reduce3.ftdata.NLM_11N_hvar_25.mat')) data = data['ftdata_NLM'] temp, _, _ = normalizeData(data[LR_flag, :].T) null_corr = sp.zeros((len(dfs_left_sm.vertices), 1000)) for iter1 in sp.arange(1000): perm1 = np.random.permutation(temp.shape[1]) d2 = temp[:, perm1] d2, R = brainSync(X=d1, Y=d2) null_corr[:, iter1] = sp.sum(d1 * d2, axis=0) print iter1, d2, R = brainSync(X=d1, Y=temp) scorr = sp.sum(d1 * d2, axis=0) c = scorr[:, None] < null_corr pval = sp.mean(c, axis=1) dfs_left_sm = patch_color_attrib(dfs_left_sm, 1 - pval, clim=[0.95, 1]) view_patch_vtk(dfs_left_sm, azimuth=-90, elevation=-180,
sub = lst[ind] data = spio.loadmat( os.path.join( p_dir, sub, sub + '.rfMRI_REST1_LR.\ reduce3.ftdata.NLM_11N_hvar_25.mat')) LR_flag = msk['LR_flag'] LR_flag = np.squeeze(LR_flag) != 0 data = data['ftdata_NLM'] # temp = data[LR_flag, :] # m = np.mean(temp, 1) # temp = temp - m[:, None] # s = np.std(temp, 1)+1e-16 # temp = temp/s[:, None] # temp = temp[:, :d1.shape[0]] d2, _, _ = normalizeData(data.T) d2, _ = brainSync(dr, d2) meanData = meanData + d2 print(ind, end=',') # %% Do the PCA np.savez('mean_data_filt.npz', meanData=meanData) p = PCA(n_components=NCMP) D = p.fit_transform(meanData.T).T # %% Explained variance _, s, _ = np.linalg.svd(np.dot(meanData, meanData.T)) plt.figure() plt.plot(s[:50]) plt.title('sigma plot') # %%
def load_all_data(atlas_labels): atlas = spio.loadmat(atlas_labels) gord_labels = atlas['labels'].squeeze() label_ids = np.unique(gord_labels) # unique label ids # remove WM label from connectivity analysis label_ids = np.setdiff1d(label_ids, (2000, 0)) # with open(epi_txt) as f: # epiIds = f.readlines() # # with open(nonepi_txt) as f: # nonepiIds = f.readlines() # # epiIds = list(map(lambda x: x.strip(), epiIds)) # nonepiIds = list(map(lambda x: x.strip(), nonepiIds)) # # random.shuffle(epiIds) # # random.shuffle(nonepiIds) # # print(len(epiIds), epiIds) # epi_files = list() # nonepi_files = list() # # for sub in epiIds: # fname = os.path.join(studydir, sub, 'BFP', sub, 'func', # sub + '_rest_bold.32k.GOrd.mat') # if os.path.isfile(fname): # epi_files.append(fname) # # for sub in nonepiIds: # fname = os.path.join(studydir, sub, 'BFP', sub, 'func', # sub + '_rest_bold.32k.GOrd.mat') # if os.path.isfile(fname): # nonepi_files.append(fname) adhd_fnames, tdc_fnames, gt_labels = load_csv() adhd_data = load_bfp_data(adhd_fnames, 235) tdc_data = load_bfp_data(tdc_fnames, 235) nsub = adhd_data.shape[2] conn_mat = np.zeros((nsub, len(label_ids), len(label_ids))) parcorr_mat = np.zeros((nsub, len(label_ids), len(label_ids))) cent_mat = np.zeros((nsub, len(label_ids))) input_feat = np.zeros((nsub, len(label_ids), adhd_data.shape[0])) print(conn_mat.shape, input_feat.shape) print(adhd_data.shape, tdc_data.shape, gord_labels.shape) _, _, ref_sub = get_connectivity(tdc_data[:, :, 0], labels=gord_labels, label_ids=label_ids) for subno in range(nsub): # num of subjects conn_mat[subno, :, :], parcorr_mat[ subno, :, :], time_series = get_connectivity(adhd_data[:, :, subno], labels=gord_labels, label_ids=label_ids) #G = nx.convert_matrix.from_numpy_array(np.abs(conn_mat[subno, :, :])) #cent = nx.eigenvector_centrality(G, weight='weight') #cent_mat[subno, :] = np.array(list(cent.items()))[:,1] # print(ref_sub.shape, time_series.shape) input_feat[subno, :, :] = np.transpose( brainSync(ref_sub.T, time_series.T)[0]) np.savez( '../ADHD_parPearson_BCI-DNI.npz', conn_mat=conn_mat, partial_mat=parcorr_mat, features=input_feat, # 36x16x171 label_ids=label_ids, cent_mat=cent_mat) ##============================================================================ print("healthy subjects") nsub = tdc_data.shape[2] conn_mat = np.zeros((nsub, len(label_ids), len(label_ids))) parcorr_mat = np.zeros((nsub, len(label_ids), len(label_ids))) cent_mat = np.zeros((nsub, len(label_ids))) input_feat = np.zeros((nsub, len(label_ids), tdc_data.shape[0])) print(conn_mat.shape, input_feat.shape) # here we are using same number of training subjects for epi and nonepi. for subno in range(nsub): conn_mat[subno, :, :], parcorr_mat[ subno, :, :], time_series = get_connectivity(tdc_data[:, :, subno], labels=gord_labels, label_ids=label_ids) #G = nx.convert_matrix.from_numpy_array(np.abs(conn_mat[subno, :, :])) #cent = nx.eigenvector_centrality(G, weight='weight') # cent_mat[subno, :] = np.array(list(cent.items()))[:,1] input_feat[subno, :, :] = np.transpose( brainSync(ref_sub.T, time_series.T)[0]) np.savez( '../TDC_parPearson_BCI-DNI.npz', conn_mat=conn_mat, # n_subjects*16*16 partial_mat=parcorr_mat, features=input_feat, # n_subjects * 16 x 171 label_ids=label_ids, cent_mat=cent_mat) print('done')