def subject_connectivity(timeseries, subjects, atlas_name, kind, iter_no='', seed=1234, validation_ext='10CV', n_subjects='', save=True, save_path=data_folder): """ timeseries : timeseries table for subject (timepoints x regions) subjects : subject IDs atlas_name : name of the parcellation atlas used kind : the kind of connectivity to be used, e.g. lasso, partial correlation, correlation iter_no : tangent connectivity iteration number for cross validation evaluation save : save the connectivity matrix to a file save_path : specify path to save the matrix if different from subject folder returns: connectivity : connectivity matrix (regions x regions) """ if kind in ['TPE', 'TE', 'correlation']: if kind not in ['TPE', 'TE']: conn_measure = connectome.ConnectivityMeasure(kind=kind) connectivity = conn_measure.fit_transform(timeseries) else: if kind == 'TPE': conn_measure = connectome.ConnectivityMeasure( kind='correlation') conn_mat = conn_measure.fit_transform(timeseries) conn_measure = connectome.ConnectivityMeasure(kind='tangent') connectivity_fit = conn_measure.fit(conn_mat) connectivity = connectivity_fit.transform(conn_mat) else: conn_measure = connectome.ConnectivityMeasure(kind='tangent') connectivity_fit = conn_measure.fit(timeseries) connectivity = connectivity_fit.transform(timeseries) if save: if kind not in ['TPE', 'TE']: for i, subj_id in enumerate(subjects): subject_file = os.path.join( save_path, subj_id, subj_id + '_' + atlas_name + '_' + kind.replace(' ', '_') + '.mat') sio.savemat(subject_file, {'connectivity': connectivity[i]}) return connectivity else: for i, subj_id in enumerate(subjects): subject_file = os.path.join( save_path, subj_id, subj_id + '_' + atlas_name + '_' + kind.replace(' ', '_') + '_' + str(iter_no) + '_' + str(seed) + '_' + validation_ext + str(n_subjects) + '.mat') sio.savemat(subject_file, {'connectivity': connectivity[i]}) return connectivity_fit
def signals_to_net(signal): estimator = connectome.ConnectivityMeasure(kind='correlation') fmri_net = estimator.fit_transform([signal])[0] # fmri_net = np.abs(fmri_net) fmri_net = normalize_mat(fmri_net) # fmri_net[fmri_net<0]=0 return fmri_net
def subject_connectivity(timeseries, subject, atlas_name, kind, save=True, save_path=data_folder): """ timeseries : timeseries table for subject (timepoints x regions) subject : the subject ID atlas_name : name of the parcellation atlas used kind : the kind of connectivity to be used, e.g. lasso, partial correlation, correlation save : save the connectivity matrix to a file save_path : specify path to save the matrix if different from subject folder returns: connectivity : connectivity matrix (regions x regions) """ print("Estimating %s matrix for subject %s" % (kind, subject)) if kind in ['tangent', 'partial correlation', 'correlation']: conn_measure = connectome.ConnectivityMeasure(kind=kind) connectivity = conn_measure.fit_transform([timeseries])[0] if save: subject_file = os.path.join( save_path, subject, subject + '_' + atlas_name + '_' + kind.replace(' ', '_') + '.mat') sio.savemat(subject_file, {'connectivity': connectivity}) return connectivity
def get_functional_connectivity(total_time_series): ''' Get the functional connectivity matrix (diagonal elements are 0) from the roi_signals parameters ---------- total_time_series: the roi_signals, list (length L). the elements are np.array with shape (T, N) where T is the time series step, N is the number of ROIs. For each element, the N should be the same but T is not. return ------ connectivity: the functional connectivity matrix from the roi_signals, np.array. the shape is (L, N, N) ''' conn_measure = connectome.ConnectivityMeasure(kind='correlation') connectivity = conn_measure.fit_transform(total_time_series) diagonal = np.diag_indices(connectivity.shape[1]) for i in range(connectivity.shape[0]): connectivity[i][diagonal] = 0 connectivity = np.arctanh(connectivity) return connectivity
def extract_mat(rsimg, maskimg, labelimg, conntype='correlation', space='labels', savets=False, nomat=False): masker = input_data.NiftiLabelsMasker(labelimg, background_label=0, smoothing_fwhm=None, standardize=False, detrend=False, mask_img=maskimg, resampling_target=space, verbose=0) # get the unique labels list, other than 0, which will be first reginparc = np.unique(labelimg.get_data())[1:].astype(np.int) reglabs = list(reginparc.astype(np.str)) # Extract time series time_series = masker.fit_transform(rsimg) if nomat: connmat = None conndf = None else: connobj = connectome.ConnectivityMeasure(kind=conntype) connmat = connobj.fit_transform([time_series])[0] conndf = get_con_df(connmat, reglabs) # if not saving time series, don't pass anything substantial, save mem if not savets: time_series = 42 return conndf, connmat, time_series, reginparc
def subject_connectivity(timeseries, subject, atlas_name, kind, save=True, save_path=root_folder): """ timeseries : timeseries table for subject (timepoints x regions) subject : the subject short ID atlas_name : name of the atlas used kind : the kind of connectivity to be used, e.g. lasso, partial correlation, correlation save : save the connectivity matrix to a file save_path : specify path to save the matrix if different from subject folder returns: connectivity : connectivity matrix (regions x regions) """ print("Estimating %s matrix for subject %s" % (kind, subject)) if kind == 'lasso': # Graph Lasso estimator covariance_estimator = GraphLassoCV(verbose=1) covariance_estimator.fit(timeseries) connectivity = covariance_estimator.covariance_ print('Covariance matrix has shape {0}.'.format(connectivity.shape)) elif kind in ['tangent', 'partial correlation', 'correlation']: conn_measure = connectome.ConnectivityMeasure(kind=kind) connectivity = conn_measure.fit_transform([timeseries])[0] if save: subject_file = os.path.join(save_path, subject, subject + '_' + atlas_name + '_' + kind.replace(' ', '_') + '.mat') sio.savemat(subject_file, {'connectivity': connectivity}) return connectivity
def extract_full_connectivity_matrix(fmri_file, mask_file, confounds_file, tr): confounds = get_confounds(confounds_file) masker_pars = { "mask_img": str(mask_file), "detrend": True, "standardize": True, "low_pass": 0.1, "high_pass": 0.01, "t_r": tr, "smoothing_fwhm": 6, "radius": 5, "allow_overlap": True } atlas = datasets.fetch_coords_seitzman_2018() network_rois_ind = atlas.networks != "unassigned" coords = np.vstack((atlas.rois['x'], atlas.rois['y'], atlas.rois['z'])).T coords = coords[network_rois_ind] time_series, excluded_rois = extract_time_series(masker_pars, fmri_file, confounds.values, coords) correlation_measure = connectome.ConnectivityMeasure(kind='correlation') connectivity_matrix = correlation_measure.fit_transform([time_series])[0] connectivity_matrix = nan_empty_rois_in_conmat(connectivity_matrix, excluded_rois.keys()) return connectivity_matrix, atlas.networks[network_rois_ind], excluded_rois
def get_connectivity(self, parcels): # Initialize empty array to store average timeseries for each ROI average_timeseries = np.zeros((0, np.size(self.timeseries['L'], axis=1))) for hem in ['L', 'R']: # For each hemisphere unique_labels = np.unique(parcels[hem]).tolist() for l in unique_labels: # Retrieve indices of timeseries corresponding to the label l binary = (parcels[hem] == l).flatten() average_timeseries = np.vstack((average_timeseries, np.mean( self.timeseries[hem][binary, :], axis=0))) if self.edge_type == 'full': corr = np.corrcoef(average_timeseries) np.fill_diagonal(corr, 0) # Fisher's z-transform self.connectivity = np.arctanh(corr) elif self.edge_type in conn_kinds: conn_measure = connectome.ConnectivityMeasure(kind=self.edge_type) self.connectivity = np.squeeze( conn_measure.fit_transform([average_timeseries.T])) else: raise ValueError('Unknown edge type') return self.connectivity
def correlation(data, kind='pearson'): ''' Compute correlation matrix of a series of voxels. Options other than Pearson's r to be implemented in the future. Args: data numpy array. Variables to be correlated are given by the rows. Returns: Numpy array of size (data.shape[0], data.shape[0]) ''' print('Computing sample correlation with %s estimator'%kind) # Compute correlation matrix of rows of 'data'. if kind is 'spearman': cor_matrix, p_vals = stats.spearmanr(data.T) if kind is 'ledoit': cor_matrix = connectome.ConnectivityMeasure(kind='correlation').fit_transform([data.T,])[0] elif kind is 'pearson': cor_matrix = np.corrcoef(data) cor_matrix[np.isnan(cor_matrix)] = 0. if kind is not 'spearman': # Compute p-value of correlation using two-sided t-test with data.shape[1]-2. # degrees of freedom. cor_matrix[cor_matrix > 0.999] = 0.999999 t_stats = cor_matrix * np.sqrt(data.shape[1] - 2.)\ / np.sqrt(1. - cor_matrix**2.) p_vals = stats.t.sf(np.abs(t_stats), data.shape[1]-2.)*2. return cor_matrix, p_vals
def extract_mat(rsimg, maskimg, labelimg, regnames=None, conntype='correlation', space='labels'): masker = input_data.NiftiLabelsMasker(labelimg, background_label=0, smoothing_fwhm=None, standardize=False, detrend=False, mask_img=maskimg, resampling_target=space, verbose=0) # Extract time series time_series = masker.fit_transform(rsimg) connobj = connectome.ConnectivityMeasure(kind=conntype) connmat = connobj.fit_transform([time_series])[0] if regnames is not None: reglabs = open(regnames).read().splitlines() else: # get the unique labels list, other than 0, which will be first reglabs = list( np.unique(labelimg.get_data())[1:].astype(np.int).astype(np.str)) conndf = get_con_df(connmat, reglabs) return conndf, connmat
def connnect_creation(df_int, kind='correlation'): """Create connectivity.""" order = df_int[1] session_nb = str(df_int[2]) filename_id = df_int[3][:-9] ts_dirty = load(filename_id + 'basc064' + '/' + 'rfMRI_REST' + session_nb + '_' + order + '_raw') ts_ortho = np.loadtxt(filename_id + 'confounds' + '/' + 'rfMRI_REST' + session_nb + '_' + order + '_Movement_Regressors.txt') ts = signal.clean(ts_dirty, detrend=True, standardize=True, confounds=ts_ortho, low_pass=None, high_pass=None, t_r=0.72, ensure_finite=False) conn_measure = connectome.ConnectivityMeasure(kind=kind) indiv_connect_mat[kind] = conn_measure.fit_transform([ts]) mean_connect_mat[kind] = indiv_connect_mat[kind].mean(axis=0) connectivity_coefs = connectome.sym_to_vec(indiv_connect_mat[kind], discard_diagonal=True) return connectivity_coefs, ts
def calculate_network(self, method, parcel_centers=False): """Calculate connectivity matrix based on functional parcellation :param method: Method used for the functional parcellation :param hemisphere: Hemisphere to which the functional parcellation corresponds """ if self.parcellation is None: raise RuntimeError('Parcellation needs to be specified.') self.method = method # Specify number of parcels num_parcels = self.parcellation.nodes # Initialize empty array to store average timeseries for each ROI average_timeseries = [] for l in range(num_parcels): members = self.parcellation.members[l, 0][0] hemisphere = self.parcellation.hemisphere[l, 0] # Retrieve indices of timeseries corresponding to the label l average_timeseries.append(np.mean( self.timeseries[hemisphere][members, :], axis=0)) average_timeseries = np.vstack(average_timeseries) if self.edge_type == 'full': corr = np.corrcoef(average_timeseries) np.fill_diagonal(corr, 0) # Fisher's z-transform self.connectivity = np.arctanh(corr) elif self.edge_type in conn_kinds: conn_measure = connectome.ConnectivityMeasure(kind=self.edge_type) self.connectivity = np.squeeze( conn_measure.fit_transform([average_timeseries.T])) else: raise ValueError('Unknown edge type') if parcel_centers: # Initialize empty array to store labels for each ROI node_labels = np.zeros((self.parcellation.midth_coords)) for l in range(num_parcels): # Get parcel center coordinates parcel_center = self.get_parcel_center( self.timeseries[hemisphere][members, :], self.vertices[hemisphere][members, :]) node_labels = np.vstack((node_labels, parcel_center)) self.labels = node_labels
def create_all_features(data, parc): """ This function gets the concatented data and produces a connectiviry matrix according to the chosen parcellation for each subject. input: data = a list of paths for the concatenated data (a poth for each subject), parc = chosen parcellation method output: all_features = a list which contains all the connectivity matrices """ all_features = [] # here is where we will put the data (a container) #Create the wanted connectivity matrix #kind{“correlation”, “partial correlation”, “tangent”, “covariance”, “precision”} correlation_measure = connectome.ConnectivityMeasure(kind='correlation') medial_mask = [] parc_shaf = [] if parc == "Schaefer": #Add medial mask to HCP data (to equalize dimensions of HCP data and Schafer parcellation file) file = conf.MEDIAL_MASK_PATH mat_contents = sio.loadmat(file) medial_mask = mat_contents['medial_mask'] print('The shape of the medial mask file is {}'.format( medial_mask.shape)) print("It should be (64984, 1).") #Schafer parcellation path_parc = conf.SCHAEFER_PARC_DIR + conf.SCHAEFER_PARC_FILE img = nib.load(path_parc) parc_shaf = img.get_fdata() print('The shape of the parc file is {}'.format(parc_shaf.shape)) for i, sub in enumerate(data): #load data load_data = np.load(data[i])['a'] parcellated_data = [] if parc == "Schaefer": print("Shafer") # add medial mask to the cortical vertices of the HCP data data_forparc = add_medial_mask(load_data, medial_mask) # parcell the data according to the schaefer parc parcellated_data = schaefer_parc(data_forparc, parc_shaf) else: print("Not Shafer") # parcell the data according to a specific atlas parcellated_data = hcp.parcellate(load_data, parc) # create a region x region correlation matrix correlation_matrix = correlation_measure.fit_transform( [parcellated_data])[0] # add to our container #np.savez_compressed(saved_dir_path + i, a = correlation_matrix) all_features.append(correlation_matrix) # keep track of status print('finished %s of %s' % (i + 1, len(data))) return all_features
def process_test_data(timeseries, transformer, ids, params, k, seed, validation_ext): conn_measure = connectome.ConnectivityMeasure(kind='correlation') test_data = conn_measure.fit_transform(timeseries) if params['connectivity'] == 'TE': connectivity = transformer.transform(timeseries) else: connectivity = transformer.transform(test_data) save_path = data_folder atlas_name = params['atlas'] kind = params['connectivity'] for i, subj_id in enumerate(ids): subject_file = os.path.join(save_path, subj_id, subj_id + '_' + atlas_name + '_' + kind.replace(' ', '_') + '_' + str(k) + '_' + str(seed) + '_' + validation_ext + str(params['n_subjects'])+'.mat') sio.savemat(subject_file, {'connectivity': connectivity[i]})
def group_connectivity(timeseries, subject_list, atlas_name, kind, save=True, save_path=root_folder): """ timeseries : list of timeseries tables for subjects (timepoints x regions) subject_list : the subject short IDs list atlas_name : name of the atlas used kind : the kind of connectivity to be used, e.g. lasso, partial correlation, correlation save : save the connectivity matrix to a file save_path : specify path to save the matrix if different from subject folder returns: connectivity : connectivity matrix (regions x regions) """ if kind == 'lasso': # Graph Lasso estimator covariance_estimator = GraphLassoCV(verbose=1) connectivity_matrices = [] for i, ts in enumerate(timeseries): covariance_estimator.fit(ts) connectivity = covariance_estimator.covariance_ connectivity_matrices.append(connectivity) print('Covariance matrix has shape {0}.'.format( connectivity.shape)) elif kind in ['tangent', 'partial correlation', 'correlation']: conn_measure = connectome.ConnectivityMeasure(kind=kind) connectivity_matrices = conn_measure.fit_transform(timeseries) if save: for i, subject in enumerate(subject_list): subject_file = os.path.join( save_path, subject_list[i], subject_list[i] + '_' + atlas_name + '_' + kind.replace(' ', '_') + '.mat') sio.savemat(subject_file, {'connectivity': connectivity_matrices[i]}) print("Saving connectivity matrix to %s" % subject_file) return connectivity_matrices
def extract_mat(rs_file, brainmask_file, roi_file, confounds_file, conf, roi_type, tr, spikereg_threshold=None): """ 36 P """ # Masker masker_pars = {"mask_img": brainmask_file, "detrend": True, "standardize": True, "low_pass": 0.1, "high_pass": \ 0.01, "t_r": tr} if roi_type == "maps": # for msdl type probablistic rois masker = input_data.NiftiMapsMasker(roi_file, **masker_pars) elif roi_type == "labels": # for binary rois masker = input_data.NiftiLabelsMasker(roi_file, **masker_pars) else: raise Exception("roi type not known {}".format(roi_type)) # Extract time series confounds, outlier_stats = get_confounds(confounds_file, kind=conf, spikereg_threshold=spikereg_threshold) time_series = masker.fit_transform(rs_file, confounds=confounds.values) con_measure = connectome.ConnectivityMeasure(kind='correlation') conmat = con_measure.fit_transform([time_series])[0] report_str = "rs_file\t{}\n".format(rs_file) report_str += "roi_file\t{}\n".format(roi_file) keys = list(masker_pars.keys()) keys.sort() for k in keys: report_str += "{}\t{}\n".format(k, masker_pars[k]) report_str += "spike regression \t {}".format(spikereg_threshold) report_str += "\n\n" report_str += "confounds\t{}".format(", ".join(confounds.columns)) report_str += "\n\n" report_str += confounds.to_string() return conmat, report_str, outlier_stats
def extract_net(in_timeseries, discard_frames=0, conntype='correlation'): hf = h5py.File(in_timeseries, 'r') reglabs = np.array(hf.get('regionids')).astype(np.str) ts = np.array(hf.get('timeseries')) print('shape of input data: {}'.format(ts.shape)) # possibly trim if discard_frames > 0: ts = ts[discard_frames:, :] print('new shape of input data: {}'.format(ts.shape)) if conntype == 'partialcorrelation': conntype = 'partial correlation' connobj = connectome.ConnectivityMeasure(kind=conntype) connmat = connobj.fit_transform([ts])[0] conndf = get_con_df(connmat, reglabs) hf.close() return conndf
def build_graph_adj_mat_newJune(pathout, mmp_atlas, atlas_name, adjacent_mat_file, graph_type='surf', coarsening_levels=6, noise_level=0.01, Nneighbours=8): #####generate brain graphs graph_perm_file = os.path.join( pathout, '_'.join([ atlas_name, graph_type, 'brain_graph_layer' + str(coarsening_levels) + '_Nei' + str(Nneighbours) + '.pkl' ])) print(graph_perm_file) if not os.path.isfile(graph_perm_file): if graph_type == 'surf': print( '\n\nLoading adjacent matrix based on counting connected vertices between parcels:', adjacent_mat_file) adj_mat = nib.load(adjacent_mat_file).get_data() adj_mat = sparse.csr_matrix(adj_mat) elif graph_type == 'SC': print( '\n\nCalculate adjacent graph based on structural covaraince of corrThickness across subjects:', adjacent_mat_file) conn_matrix = nib.load(adjacent_mat_file).get_data() Subject_Num, Node_Num = conn_matrix.shape atlas_roi = nib.load(mmp_atlas).get_data() RegionLabels = [i for i in np.unique(atlas_roi) if i > 0] Region_Num = len(RegionLabels) tc_matrix_df = pd.DataFrame(data=conn_matrix.ravel(), columns=['tc_signal']) tc_matrix_df['roi_label'] = np.repeat(atlas_roi.astype('int'), Subject_Num, axis=0).ravel() tc_matrix_df['subj'] = np.repeat(np.arange(Subject_Num).reshape( (Subject_Num, 1)), Node_Num, axis=1).ravel() # df = pd.DataFrame(values, index=index) tc_roi = tc_matrix_df.groupby(['subj', 'roi_label']) tc_roi_matrix = tc_roi.mean().values.reshape( Subject_Num, Region_Num) ################# corr_kind = 'partial correlation' #'correlation' ## connectome_measure = connectome.ConnectivityMeasure(kind=corr_kind) # connectome_measure = connectome.GroupSparseCovarianceCV() # corr_matrix = connectome_measure.fit_transform(np.transpose(subjects_tc_matrix)) corr_matrix = connectome_measure.fit_transform( np.expand_dims(tc_roi_matrix, axis=0)) corr_matrix_z = np.tanh( connectome_measure.mean_) ##convert to z-score sig = 0.25 corr_matrix_z = np.exp( corr_matrix_z / sig) ##a Gaussian kernel, defined in Shen 2010 # k-NN graph. idx = np.argsort(-corr_matrix_z)[:, 1:Nneighbours + 1] dist = np.array([ corr_matrix_z[i, idx[i]] for i in range(corr_matrix_z.shape[0]) ]) dist[dist < 1] = 0 adj_mat = graph.adjacency(dist, idx) elif graph_type == 'RSFC': from utils import load_rsfmri_data_matrix subjects_tc_matrix, subname_coding = load_rsfmri_data_matrix( adjacent_mat_file) if not os.path.isfile(pathout + atlas_name + '_avg_RSFC_matrix.pkl'): corr_kind = 'tangent' print('using %s for connectivity measure...' % corr_kind) connectome_measure = connectome.ConnectivityMeasure( kind=corr_kind) corr_matrix = connectome_measure.fit_transform( np.transpose(subjects_tc_matrix, (0, 2, 1))) corr_matrix_z = np.tanh( connectome_measure.mean_ ) ##np.mean(np.arctanh(corr_matrix),axis=0) with open(pathout + atlas_name + '_avg_RSFC_matrix.pkl', 'wb') as f: # Python 3: open(..., 'wb') pickle.dump([corr_matrix_z], f) else: with open(pathout + atlas_name + '_avg_RSFC_matrix.pkl', 'rb') as f: # Python 3: open(..., 'rb') corr_matrix_z = pickle.load(f) corr_matrix_z = corr_matrix_z[0] ##sig = 0.01 sig = np.mean(corr_matrix_z) corr_matrix_z = np.exp( corr_matrix_z / sig) ##a Gaussian kernel, defined in Shen 2010 print( sig, np.histogram(corr_matrix_z, bins=np.arange(10), density=True)) # k-NN graph. idx = np.argsort(-corr_matrix_z)[:, 1:Nneighbours + 1] dist = np.array([ corr_matrix_z[i, idx[i]] for i in range(corr_matrix_z.shape[0]) ]) dist[dist < 1] = 0 adj_mat = graph.adjacency(dist, idx) A = graph.replace_random_edges(adj_mat, noise_level) ###build multi-level graph using coarsen (div by 2 at each level) graphs, perm = coarsening.coarsen(A, levels=coarsening_levels, self_connections=False) L = [graph.laplacian(A, normalized=True) for A in graphs] with open(graph_perm_file, 'wb') as f: # Python 3: open(..., 'wb') pickle.dump([A, perm, L], f) else: # Getting back the objects: with open(graph_perm_file, 'rb') as f: # Python 3: open(..., 'rb') A, perm, L = pickle.load(f) return A, perm, L
'verbose': 1 } masker = NiftiMapsMasker(maps_img=maps_img, **mask_params) subjects_timeseries = [] dx_groups = [] for label, func_img in zip(phenotypes['DX_GROUP'], func_imgs): confounds = extract_confounds(func_img, mask_img=gm_mask, n_confounds=10) signals = masker.fit_transform(func_img, confounds=confounds) subjects_timeseries.append(signals) dx_groups.append(label) ############################################################################## # Functional Connectomes # ---------------------- connectome_measure = connectome.ConnectivityMeasure( cov_estimator=LedoitWolf(assume_centered=True), kind='tangent', vectorize=True) # Vectorized connectomes across subject-specific timeseries vec = connectome_measure.fit_transform(subjects_timeseries) ############################################################################## # Linear model # ------------- # Logistic Regression 'l2' estimator = LogisticRegression(penalty='l2', random_state=0) cv = StratifiedShuffleSplit(n_splits=20, test_size=0.25, random_state=0) scores = cross_val_score(estimator, vec, dx_groups, scoring='roc_auc', cv=cv)
def get_networks(subject_list, variable, isDynamic, isEffective): """ subject_list : list of subject IDs kind : the kind of connectivity to be used, e.g. lasso, partial correlation, correlation atlas_name : name of the parcellation atlas used variable : variable name in the .mat file that has been used to save the precomputed networks return: matrix : feature matrix of connectivity networks (num_subjects x network_size) """ with open('name.data', 'rb') as f: name = pickle.load(f) with open('alff.data', 'rb') as f: alff = pickle.load(f) with open('reho.data', 'rb') as f: reho = pickle.load(f) dynamicset = [] all_networks = [] timeseries_set = [] if isEffective == True: fc = sio.loadmat( os.path.join('./EffectiveFC/Before_Dropout/0.1.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/Before_Dropout/0.01.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/Before_Dropout/0.001.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/Before_Dropout/0.2.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/Before_Dropout/0.5.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/Before_Dropout/0.05.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/Before_Dropout/0.15.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.001.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.01.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.05.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.1.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.15.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.2.mat'))['sparse_f'] # fc = sio.loadmat(os.path.join('./EffectiveFC/After_Dropout/0.5.mat'))['sparse_f'] for i in range(len(subject_list)): all_networks.append(fc[:, :, i]) # all_networks_set = np.dstack(all_networks) # matrix = np.transpose(all_networks_set, (2,0,1)) vec_networks = [np.reshape(mat, [1, -1]) for mat in all_networks] matrix = np.vstack(vec_networks) else: for subject in subject_list: flname = [ i for i in os.listdir(data_folder) if os.path.isfile(os.path.join(data_folder, i)) and subject in i ] fl = os.path.join(data_folder, flname[0]) # Estimate connectivity matrix timeseries = sio.loadmat(fl)['ROI'] if variable == 'correlation': conn_measure = connectome.ConnectivityMeasure(kind=variable) # conn_measure = connectome.ConnectivityMeasure(kind=variable).fit_transform([timeseries])[0] # conn_measure_2nd = np.matmul(conn_measure, conn_measure) # conn_measure_3rd = np.matmul(conn_measure, conn_measure_2nd) # connectivity = conn_measure + conn_measure_2nd + conn_measure_3rd ft = conn_measure.fit_transform([timeseries])[0] elif variable == 'graph_measure': conn_measure = connectome.ConnectivityMeasure( kind='correlation') connectivity = conn_measure.fit_transform([timeseries])[0] ft = bct.clustering_coef_wu(connectivity) timeseries_set.append(timeseries) all_networks.append(ft) dynamicset.append( np.concatenate( (alff[name.index(subject)], reho[name.index(subject)]))) # all_networks=np.array(all_networks) if variable == 'correlation': idx = np.triu_indices_from(all_networks[0], 1) norm_networks = [np.arctanh(mat) for mat in all_networks] vec_networks = [mat[idx] for mat in norm_networks] # vec_networks = [mat[idx] for mat in all_networks] matrix = np.vstack(vec_networks) elif variable == 'graph_measure': matrix = np.vstack(all_networks) # all_networks_set = np.dstack(all_networks) # matrix = np.transpose(all_networks_set, (2,0,1)) # if isDynamic == True: # dynamicset = np.vstack(dynamicset) # matrix = np.concatenate((matrix, dynamicset), axis=1) # # # with open('./train_data.pkl', 'wb') as filehandle: # pickle.dump(timeseries_set, filehandle) return matrix
def compute_single_connectivity(timeseries): correlation_measure = connectome.ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform([timeseries])[0] np.fill_diagonal(correlation_matrix, 0) return correlation_matrix
ts = np.load(output_dir + '/sub-' + subject + '_ses-' + ses + '.npy', allow_pickle=True) event = event_template.format(sub=subject, ses=ses) events = pd.read_csv(event, sep='\t') onset = int( events.onset[events.trial_type_30 == 'trauma1_0']) # take onset of trauma first script ts_script = ts[onset:onset + duration, :] sub_ts.append(ts_script) return sub_ts # %% from nilearn import connectome connectome = connectome.ConnectivityMeasure(kind='correlation', vectorize=False) mat_ses1 = connectome.fit_transform(pooledTS(subject_list, '1')) # %% plot mean matrix nilearn.plotting.plot_matrix(connectome.mean_, colorbar=True, labels=range(256), reorder='average') # %% lets run ses 2 mat_ses2 = connectome.fit_transform(pooledTS(subject_list, '2')) nilearn.plotting.plot_matrix(connectome.mean_, colorbar=True, labels=range(256),
def testNilearn(workDir, dataDir, saveIntermediate): """ :param workDir: the directory where the result files are stored :param dataDir: the directory where data files can be found :param saveIntermediate: determine if the intermediate files will be saved :return: None """ filenames = os.listdir(dataDir + '/fMRI/') filenames.sort() img_names = [ dataDir + '/fMRI/' + filename + '/' + filename + '.nii' for filename in filenames ] resultDir = workDir + '/connectivity_matrices/' os.makedirs(resultDir) connectivity_matrices = {} for idx, img_name in enumerate(img_names): logging.info('Computing image of subject %s. (Progress: %s/%s)' % (filenames[idx], str(idx + 1), str(len(img_names)))) img = nilearn.image.load_img(img_name) logging.info('Preprocessing image ...step1') # confounds = nilearn.image.high_variance_confounds(img, n_confounds=5, percentile=2.0) # img = nilearn.image.clean_img(img, detrend=True, standardize=True, confounds=confounds) img = nilearn.image.smooth_img(img, 4) coords_table = pd.read_csv(dataDir + '/atlas/AAL90.csv', encoding='gbk') coords = pd.concat( [coords_table.MNIX, coords_table.MNIY, coords_table.MNIZ], axis=1) masker = input_data.NiftiLabelsMasker(labels_img=dataDir + '/atlas/AAL_Contract_90_2MM.nii', standardize=True, memory='nilearn_cache') time_series = masker.fit_transform(img) if saveIntermediate != 'n': intermDir = workDir + '/intermediate_files/' if not os.path.exists(intermDir): os.makedirs(intermDir) plotting.plot_img(img.slicer[:, :, :, 100]) plt.savefig(intermDir + filenames[idx] + '_preprocessed_step1.png') logging.info('Computing connectome ...step2') connectivity_measure = connectome.ConnectivityMeasure( kind='correlation') connectivity_matrix = connectivity_measure.fit_transform([time_series ])[0] connectivity_matrices[filenames[idx]] = connectivity_matrix if saveIntermediate != 'n': plotting.plot_matrix(connectivity_matrix, colorbar=True, vmax=0.8, vmin=-0.8) plt.savefig(intermDir + filenames[idx] + '_matrix_step2.png') plotting.plot_connectome(connectivity_matrix, coords, edge_threshold="97%", colorbar=True) plt.savefig(intermDir + filenames[idx] + '_connectome_step2.png') with codecs.open(resultDir + '/' + filenames[idx] + '.csv', 'w+', encoding='gbk') as result_csv: writer = csv.writer(result_csv, delimiter=',') for row in connectivity_matrix: writer.writerow(row) with open( workDir + '/' + os.environ['USERNAME'] + '_' + time.strftime('%y%m%d') + '_' + str(len(filenames)) + '_bcn.pkl', 'wb') as pkl_file: pickle.dump(connectivity_matrices, pkl_file)
subs_fact = 8 for i, kind in enumerate(kinds): for j, session_nb in enumerate(whoistrain): for k, order in enumerate(orders): first_all_sess_msk = np.array((df['session_nb'] == session_nb) & (df['order'] == order)) secnd_all_sess_msk = np.array((df['session_nb'] != session_nb) & (df['order'] == order)) ts_all_array = np.array(ts_all, dtype=object) ts_fst = list(ts_all_array[first_all_sess_msk][::subs_fact]) ts_secnd = list(ts_all_array[secnd_all_sess_msk][::subs_fact]) conn_measure = connectome.ConnectivityMeasure(kind=kind) indiv_connect_mat = conn_measure.fit_transform(ts_fst) connectivity_fst = connectome.sym_to_vec(indiv_connect_mat, discard_diagonal=True) indiv_connect_mat = conn_measure.transform(ts_secnd) connectivity_secnd = connectome.sym_to_vec(indiv_connect_mat, discard_diagonal=True) X_train_all = connectivity_fst y_train = y[first_all_sess_msk][::subs_fact] X_test_all = connectivity_secnd y_test = y[secnd_all_sess_msk][::subs_fact] clf = KNeighborsClassifier(n_neighbors=1)
def connectivity(layout, subject, session, task, atlas, connectivity_metric='correlation', confounds=None, out_dir=None): """ Makes connectivity matrices per subject per session per task per condition. Parameters ---------- layout : str BIDS layout with derivatives indexed from pyBIDS subject : str Subject ID for which the networks will be calculated. session : str, optional Session of data collection. If there's only one session, we'll find it. connectivity_metric : {"correlation", "partial correlation", "tangent",\ "covariance", "precision"}, optional The matrix kind. Passed to Nilearn's `ConnectivityMeasure`. space : str 'native' if analyses will be performed in subjects' functional native space (atlas(es) should be transformed) 'mni152-2mm' if analyses will be performed in MNI125 2mm isotropic space (fMRI data should already be transformed) atlas : str Name of atlas for parcellating voxels into nodes, must be in the same `space` given above. confounds : list-like Names of confounds (should be columns in fmriprep output confounds.tsv). Returns ------- adjacency_matrix """ try: version = idconn.__version__ except: version = 'test' if '.nii' in atlas: assert exists(atlas), f'Mask file does not exist at {atlas}' if not out_dir: deriv_dir = join(layout.root, 'derivatives', f'idconn-{version}') else: deriv_dir = out_dir atlas_name = basename(atlas).rsplit('.', 2)[0] # use pybids here to grab # of runs and preproc bold filenames connectivity_measure = connectome.ConnectivityMeasure( kind=connectivity_metric) bold_files = layout.get( scope='derivatives', return_type='file', suffix='bold', task=task, space='MNI152NLin2009cAsym', subject=subject, session=session, extension='nii.gz' ) # should be preprocessed BOLD file from fmriprep, grabbed with pybids print(f'BOLD files found at {bold_files}') confounds_files = layout.get(scope='derivatives', return_type='file', desc='confounds', subject=subject, session=session, task=task) runs = [] if len(bold_files) > 1: for i in range(0, len(bold_files)): assert exists( bold_files[i] ), "Preprocessed bold file(s) does not exist at {0}".format( bold_files) runs.append(layout.parse_file_entities(bold_files[i])['run']) else: runs = None print(f'Found runs: {runs}') out = join(deriv_dir, f'sub-{subject}', f'ses-{session}', 'func') if not exists(out): makedirs(out) #event_files = layout.get(return_type='filename', suffix='events', task=task, subject=subject) #timing = pd.read_csv(event_files[0], header=0, index_col=0, sep='\t') #conditions = timing['trial_type'].unique() if runs: corrmats = {} for run in runs: print('run = ', run) # read in events file for this subject, task, and run confounds_file = layout.get(scope='derivatives', return_type='file', desc='confounds', subject=subject, session=session, task=task, run=run, extension='tsv') print(f'Confounds file located at: {confounds_file}') confounds_df = pd.read_csv(confounds_file[0], header=0, sep='\t') confounds_df = confounds_df[confounds].fillna(0) confounds_fname = join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_run-{run}_desc-confounds_timeseries.tsv' ) confounds_df.to_csv(confounds_fname, sep='\t') bold_file = layout.get(scope='derivatives', return_type='file', suffix='bold', task=task, space='MNI152NLin2009cAsym', subject=subject, session=session, extension='nii.gz', run=run) assert len( bold_file ) == 1, f'BOLD file improperly specified, more than one .nii.gz file with {subject}, {session}, {task}, {run}: {bold_file}' tr = layout.get_tr(bold_file) masker = input_data.NiftiLabelsMasker(atlas, standardize=True, t_r=tr, verbose=2) ex_bold = image.index_img(bold_file[0], 2) display = plotting.plot_epi(ex_bold) display.add_contours(atlas) display.savefig( join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_run-{run}_desc-atlas_overlay.png' )) print(f'BOLD file located at {bold_file}\nTR = {tr}s') try: #for each parcellation, extract BOLD timeseries print( f'Extracting bold signal for sub-{subject}, ses-{session}, run-{run}...' ) timeseries = masker.fit_transform(bold_file[0], confounds_fname) except Exception as e: print('ERROR: Trying to extract BOLD signals, but', e) try: print( f'Making correlation matrix for for sub-{subject}, ses-{session}, task-{task}, run-{run}...' ) corrmats[run] = connectivity_measure.fit_transform( [timeseries])[0] except Exception as e: print('ERROR: Trying to make corrmat, but', e) data = list(corrmats.values()) stacked_corrmats = np.array(data) print('Stacked corrmats have dimensions', stacked_corrmats.shape) avg_corrmat = np.mean(stacked_corrmats, axis=0) else: confounds_file = layout.get(scope='derivatives', return_type='file', desc='confounds', subject=subject, session=session, task=task, extension='tsv') print(f'Confounds file located at: {confounds_file}') confounds_df = pd.read_csv(confounds_file[0], header=0, sep='\t') confounds_df = confounds_df[confounds].fillna(0) confounds_fname = join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_desc-confounds_timeseries.tsv' ) confounds_df.to_csv(confounds_fname, sep='\t') bold_file = layout.get(scope='derivatives', return_type='file', suffix='bold', task=task, space='MNI152NLin2009cAsym', subject=subject, session=session, extension='nii.gz') assert len( bold_file ) == 1, f'BOLD file improperly specified, more than one .nii.gz file with {subject}, {session}, {task}: {bold_file}' tr = layout.get_tr(bold_file) masker = input_data.NiftiLabelsMasker(atlas, standardize=True, t_r=tr, verbose=2) ex_bold = image.index_img(bold_file[0], 2) display = plotting.plot_epi(ex_bold) display.add_contours(atlas) display.savefig( join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_desc-atlas_overlay.png' )) print(f'BOLD file located at {bold_file}\nTR = {tr}s') try: #for each parcellation, extract BOLD timeseries print( f'Extracting bold signal for sub-{subject}, ses-{session}...') timeseries = masker.fit_transform(bold_file[0], confounds_fname) except Exception as e: print('ERROR: Trying to extract BOLD signals, but', e) try: print( f'Making correlation matrix for for sub-{subject}, ses-{session}...' ) avg_corrmat = connectivity_measure.fit_transform([timeseries])[0] except Exception as e: print('ERROR: Trying to make corrmat, but', e) print('Correlation matrix created, dimensions:', avg_corrmat.shape) try: corrmat_df = pd.DataFrame(index=np.arange(1, avg_corrmat.shape[0] + 1), columns=np.arange(1, avg_corrmat.shape[0] + 1), data=avg_corrmat) corrmat_file = join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_space-MNI152NLin2009cAsym_atlas-{atlas_name}_desc-corrmat_bold.tsv' ) corrmat_df.to_csv(corrmat_file, sep='\t') except Exception as e: print('ERROR saving corrmat...', e) return corrmat_df, corrmat_file
def task_connectivity(layout, subject, session, task, atlas, confounds, connectivity_metric='correlation', out_dir=None): """ Makes connectivity matrices per subject per session per task per condition. Parameters ---------- dset_dir : str BIDS-formatted dataset path (top-level, in which a 'derivatives/' directory will be made if one does not exist) subject : str Subject ID for which the networks will be calculated. session : str, optional Session of data collection. If there's only one session, we'll find it. task : str Name of task fMRI scan from which networks will be calculated. connectivity_metric : {"correlation", "partial correlation", "tangent",\ "covariance", "precision"}, optional The matrix kind. Passed to Nilearn's `ConnectivityMeasure`. space : str 'native' if analyses will be performed in subjects' functional native space (atlas(es) should be transformed) 'mni152-2mm' if analyses will be performed in MNI125 2mm isotropic space (fMRI data should already be transformed) atlas : str If you want to grab an atlas using Nilearn, this is the name of the atlas and must match the corresponding function `fetch_atlas_[name]` in `nilearn.datasets`. If you have your own atlas, this is the path to that nifti file.` confounds : list-like Filenames of confounds files. Returns ------- confounds_file : str Filename of merged confounds .tsv file """ #version = '0.1.1' try: version = idconn.__version__ except: version = 'test' if '.nii' in atlas: assert exists(atlas), f'Mask file does not exist at {atlas}' if not out_dir: deriv_dir = join(layout.root, 'derivatives', f'idconn-{version}') else: deriv_dir = out_dir space = 'MNI152NLin2009cAsym' atlas_name = basename(atlas).rsplit('.', 2)[0] # use pybids here to grab # of runs and preproc bold filenames connectivity_measure = connectome.ConnectivityMeasure( kind=connectivity_metric) bold_files = layout.get( scope='derivatives', return_type='file', suffix='bold', task=task, space=space, subject=subject, session=session, extension='nii.gz' ) # should be preprocessed BOLD file from fmriprep, grabbed with pybids print(f'BOLD files found at {bold_files}') runs = [] if len(bold_files) > 1: for i in range(0, len(bold_files)): assert exists( bold_files[i] ), "Preprocessed bold file(s) does not exist at {0}".format( bold_files) runs.append(layout.parse_file_entities(bold_files[i])['run']) else: runs = None print(f'Found runs: {runs}') out = join(deriv_dir, f'sub-{subject}', f'ses-{session}', 'func') if not exists(out): makedirs(out) event_files = layout.get(return_type='filename', suffix='events', task=task, subject=subject) timing = pd.read_csv(event_files[0], header=0, index_col=0, sep='\t') conditions = timing['trial_type'].unique() run_cond = {} corrmats = {} for run in runs: bold_file = layout.get(scope='derivatives', return_type='file', suffix='bold', task=task, space='MNI152NLin2009cAsym', subject=subject, session=session, extension='nii.gz', run=run) assert len( bold_file ) == 1, f'BOLD file improperly specified, more than one .nii.gz file with {subject}, {session}, {task}, {run}: {bold_file}' tr = layout.get_tr(bold_file) #load timing file #update to use pyBIDS + layout event_file = layout.get(return_type='filename', suffix='events', task=task, subject=subject, run=run, session=session) print('# of event files =', len(event_file), '\nfilename = ', event_file[0]) the_file = str(event_file[0]) assert exists(the_file), 'file really does not exist' timing = pd.read_csv(the_file, header=0, index_col=0, sep='\t') timing.sort_values('onset') confounds_file = layout.get(scope='derivatives', return_type='file', desc='confounds', subject=subject, session=session, task=task, run=run, extension='tsv') print(f'Confounds file located at: {confounds_file}') confounds_df = pd.read_csv(confounds_file[0], header=0, sep='\t') confounds_df = confounds_df[confounds].fillna(0) confounds_fname = join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_run-{run}_desc-confounds_timeseries.tsv' ) confounds_df.to_csv(confounds_fname, sep='\t') masker = input_data.NiftiLabelsMasker(atlas, standardize=True, t_r=tr, verbose=2) ex_bold = image.index_img(bold_file[0], 2) display = plotting.plot_epi(ex_bold) display.add_contours(atlas) display.savefig( join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_run-{run}_desc-{atlas_name}_overlay.png' )) print(f'BOLD file located at {bold_file}\nTR = {tr}s') masker = input_data.NiftiLabelsMasker(atlas, standardize=True, t_r=tr, verbose=1) timeseries = masker.fit_transform(bold_file[0], confounds=confounds_fname) #load timing file #update to use pyBIDS + layout try: #and now we slice into conditions for condition in conditions: run_cond[condition] = {} corrmats[condition] = {} blocks = [] cond_timing = timing[timing['trial_type'] == condition] for i in cond_timing.index: blocks.append( (cond_timing.loc[i]['onset'] / tr, ((cond_timing.loc[i]['onset'] + cond_timing.loc[i]['duration']) / tr) + 1)) if len(blocks) > 1: run_cond[condition][run] = np.vstack( (timeseries[int(blocks[0][0]):int(blocks[0][1]), :], timeseries[int(blocks[1][0]):int(blocks[1][1]), :])) if len(blocks) > 2: for i in np.arange(2, len(blocks)): run_cond[condition][run] = np.vstack(( timeseries[int(blocks[0][0]):int(blocks[0][1]), :], timeseries[int(blocks[1][0]):int(blocks[1][1]), :] )) #print('extracted signals for {0}, {1}, {2}'.format(task, run, condition), run_cond['{0}-{1}'.format(run, condition)].shape) else: pass print(f'Making correlation matrix for {run}, {condition}.') corrmats[condition][run] = connectivity_measure.fit_transform( [run_cond[condition][run]])[0] print('And that correlation matrix is', corrmats[condition][run].shape) except Exception as e: print('trying to slice and dice, but', e) #and paste together the timeseries from each run together per condition files = [] avg_corrmats = {} print('Corrmats per run per condition have been made!') for condition in conditions: print(f'Merging corrmats for {task}-{condition}...') data = list(corrmats[condition].values()) stacked_corrmats = np.array(data) print('Stacked corrmats have dimensions', stacked_corrmats.shape) avg_corrmat = np.mean(stacked_corrmats, axis=0) corrmat_df = pd.DataFrame(index=np.arange(1, avg_corrmat.shape[0] + 1), columns=np.arange(1, avg_corrmat.shape[0] + 1), data=avg_corrmat) avg_corrmats[condition] = corrmat_df corrmat_file = join( deriv_dir, f'sub-{subject}', f'ses-{session}', 'func', f'sub-{subject}_ses-{session}_task-{task}_condition-{condition}_desc-{atlas_name}_corrmat.tsv' ) try: corrmat_df.to_csv(corrmat_file, sep='\t') files.append(corrmat_file) except Exception as e: print('saving corrmat...', e) return files, avg_corrmats
# extract and store timeseries of ICA components masker = input_data.NiftiMapsMasker(maps_img=icares, standardize=True, memory='nilearn_cache', verbose=1) ts = masker.fit_transform(img) fnm = out_pref + 'ts.csv' pandas.DataFrame(ts).to_csv(fnm, index=False) # Remove the same ICs that iStaging analysis removes ics = [x for x in range(100) if x not in ics_to_remove] ts = ts[:, ics] # Get and store derivatives # full correlation correlation_measure = connectome.ConnectivityMeasure(kind='correlation') cmat = correlation_measure.fit_transform([ts])[0] np.fill_diagonal(cmat, 0) fnm = out_pref + 'fullcorr.csv' pandas.DataFrame(cmat).to_csv(fnm, index=False) # partial correlation correlation_measure = connectome.ConnectivityMeasure( kind="partial correlation") cmat = correlation_measure.fit_transform([ts])[0] np.fill_diagonal(cmat, 0) fnm = out_pref + 'partcorr.csv' pandas.DataFrame(cmat).to_csv(fnm, index=False) # nodal amplitude namp = np.std(ts, axis=0)
def extract_mat(rsimg, maskimg, labelimg, conntype='correlation', space='labels', savets=False, nomat=False, dtr=False, stdz=False): masker = input_data.NiftiLabelsMasker(labelimg, background_label=0, smoothing_fwhm=None, standardize=stdz, detrend=dtr, mask_img=maskimg, resampling_target=space, verbose=1) # mask the labimg so that there are no regions that dont have data from nilearn.image import resample_to_img if space == 'data': # resample_to_image(source, target) # assume here that the mask is also fmri space resamplabs = resample_to_img(labelimg,maskimg,interpolation='nearest') resampmask = resample_to_img(maskimg,maskimg,interpolation='nearest') else: resamplabs = resample_to_img(labelimg,labelimg,interpolation='nearest') resampmask = resample_to_img(maskimg,labelimg,interpolation='nearest') # mask from nilearn.masking import apply_mask resamplabsmasked = apply_mask(resamplabs,resampmask) # get the unique labels list, other than 0, which will be first #reginparc = np.unique(resamplabs.get_fdata())[1:].astype(np.int) reginparc = np.unique(resamplabsmasked)[1:].astype(np.int) reglabs = list(reginparc.astype(np.str)) reginorigparc = np.unique(labelimg.get_fdata())[1:].astype(np.int) if len(reginparc) != len(reginorigparc): print('\n !!!WARNING!!! during resampling of label image, some of the' ' ROIs (likely very small) were interpolated out. Please take ' 'care to note which ROIs are present in the output data\n') print('ALTERNATIVELY, your parcellation is not in the same space' 'as the bold data.\n') if abs(len(reginparc) - len(reginorigparc)) > 9: print('\nBASED ON QUICK HEURISTIC...I think your parcellation ' 'is not in the right space. Please check that the two ' 'images are aligned properly.') # Extract time series time_series = masker.fit_transform(rsimg) if nomat: connmat = None conndf = None else: connobj = connectome.ConnectivityMeasure(kind=conntype) connmat = connobj.fit_transform([time_series])[0] conndf = get_con_df(connmat, reglabs) # if not saving time series, don't pass anything substantial, save mem if not savets: time_series = 42 return conndf, connmat, time_series, reginparc
#subject_list = ['KPE1223'] subject_ts = [] ses = '2' for sub in subject_list: print(f' Analysing subject {sub}') subject = sub.split('KPE')[1] func = func_template.format(sub=subject, session=ses) confound = confound_template.format(sub=subject, session=ses) signals = masker.fit_transform(imgs=func, confounds=removeVars(confound)) subject_ts.append(signals) #%% generate connectivity matrix from sklearn.covariance import LedoitWolf connectome_measure = connectome.ConnectivityMeasure( cov_estimator=LedoitWolf(assume_centered=True), kind='partial correlation', vectorize=True) # Vectorized connectomes across subject-specific timeseries vec = connectome_measure.fit_transform(subject_ts) # %% XGboost from xgboost import XGBClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score from sklearn.model_selection import StratifiedKFold
dosenbach_timeseries = dosenbach_masker.fit_transform( adhd.func[0], confounds=adhd.confounds[0]) ############################################################################### # Extract and plot correlation matrix for atlas in ['Power', 'Dosenbach']: if atlas == 'Power': timeseries = power_timeseries coords = power_coords else: timeseries = dosenbach_timeseries coords = dosenbach_coords connectivity = connectome.ConnectivityMeasure(kind='correlation') corr_matrix = connectivity.fit_transform([timeseries])[0] np.fill_diagonal(corr_matrix, 0) plt.figure() vmax = np.max(np.abs(corr_matrix)) plt.imshow(corr_matrix, vmin=-vmax, vmax=vmax, cmap='RdBu_r', interpolation='nearest') plt.colorbar() plt.title(atlas + 'correlation matrix') # Plot the connectome plotting.plot_connectome(corr_matrix,