def plot_connectome(mat, label_map, threshold='95%', GS=True): if GS: mat = mat[1:, 1:] #fisrt row and column is global signal coords = plotting.find_parcellation_cut_coords(label_map) view = plotting.view_connectome(mat, coords, threshold=threshold) view.open_in_browser()
def get_names_and_coords_of_parcels(uatlas): """ Return list of coordinates and max label intensity for a 3D atlas parcellation image. Parameters ---------- uatlas : str File path to atlas parcellation Nifti1Image in MNI template space. Returns ------- coords : list List of (x, y, z) tuples corresponding to the center-of-mass of each parcellation node. atlas : str An arbitrary identified for the atlas based on the filename. par_max : int The maximum label intensity in the parcellation image. """ import os.path as op from nilearn.plotting import find_parcellation_cut_coords if not op.isfile(uatlas): raise ValueError( '\nERROR: User-specified atlas input not found! Check that the file(s) specified with the -ua ' 'flag exist(s)') atlas = uatlas.split('/')[-1].split('.')[0] [coords, label_intensities] = find_parcellation_cut_coords(uatlas, return_label_names=True) print("%s%s" % ('Region intensities:\n', label_intensities)) par_max = len(coords) return coords, atlas, par_max
def get_names_and_coords_of_parcels(uatlas_select): from nilearn.plotting import find_parcellation_cut_coords atlas_select = uatlas_select.split('/')[-1].split('.')[0] [coords, label_intensities] = find_parcellation_cut_coords(uatlas_select, return_label_names=True) print("%s%s" % ('Region intensities:\n', label_intensities)) par_max = len(coords) return coords, atlas_select, par_max
def plot_connectome_mixture(data=None, index=None, metric="correlation", save_as=None, show=False, **kwargs): # extract time series from all subjects and concatenate them mm = data.X[index, :].copy() time_series = [np.vstack(mm)] # calculate correlation matrices across indexed frames in data connectome_measure = ConnectivityMeasure(kind=metric) connectome_measure.fit_transform(time_series) connectivity = connectome_measure.mean_ np.fill_diagonal(connectivity, 0) #connectivity[np.abs(connectivity) < 0.2] = 0.0 # grab center coordinates for atlas labels atlas = kwargs.pop('atlas', data.atlas) coords = plotting.find_parcellation_cut_coords(labels_img=atlas) # assign node colors cmap = kwargs.pop('cmap', 'jet') node_cmap = plt.get_cmap('bone') node_norm = mpl.colors.Normalize(vmin=-0.8, vmax=1.2) node_colors = np.ravel([_[-1] for i,_ in enumerate(coords)]) node_colors = [_ / np.max(node_colors) for _ in node_colors] node_colors = node_cmap(node_norm(node_colors)) # plot connectome matrix fig = plt.figure(figsize=(12,5)) ax = plt.subplot2grid((1, 2), (0, 1), rowspan=1, colspan=1) display = plotting.plot_matrix( connectivity, vmin=-.5, vmax=.5, colorbar=True, cmap=cmap, axes=ax, #title='{} Matrix'.format(metric.title()), ) # plot connectome with 99.7% edge strength in the connectivity ax = plt.subplot2grid((1, 2), (0, 0), rowspan=1, colspan=1) display = plotting.plot_connectome( connectivity, coords, edge_threshold="99.9%", display_mode='z', node_color=node_colors, node_size=20, edge_kwargs=dict(lw=4), edge_vmin=-.8, edge_vmax=.8, edge_cmap=cmap, colorbar=False, black_bg=not True, alpha=0.5, annotate=False, axes=ax, ) if show is True: plt.show() plt.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95) if save_as: fig.savefig(save_as, transparent=True)#, facecolor='slategray', edgecolor='white') plt.close(fig) return display
def get_names_and_coords_of_parcels(uatlas_select): import os.path as op from nilearn.plotting import find_parcellation_cut_coords if not op.isfile(uatlas_select): raise ValueError( '\nERROR: User-specified atlas input not found! Check that the file(s) specified with the -ua ' 'flag exist(s)') atlas_select = uatlas_select.split('/')[-1].split('.')[0] [coords, label_intensities] = find_parcellation_cut_coords(uatlas_select, return_label_names=True) print("%s%s" % ('Region intensities:\n', label_intensities)) par_max = len(coords) return coords, atlas_select, par_max
def nbs_and_graphs(corr1, corr2, p_thresh, k, atlas, verbose): coordinates = plotting.find_parcellation_cut_coords(labels_img=atlas) corr1 = np.asarray(corr1, dtype="float") corr2 = np.asarray(corr2, dtype="float") if corr1.shape[0] != corr1.shape[1]: corr1 = np.moveaxis(corr1, 0, -1) corr2 = np.moveaxis(corr2, 0, -1) thresh = stats.t.isf(p_thresh, corr1.shape[2]) pval, adj, _ = bct.nbs_bct( corr1, corr2, thresh, k=k, tail="both", paired=True, verbose=verbose ) print(pval) gridkw = dict(width_ratios=[1, 2]) fig, (ax1, ax2) = plt.subplots(1, 2, gridspec_kw=gridkw, figsize=(15, 4)) g = sns.heatmap(adj, square=True, ax=ax1, cmap="Greys") h = plotting.plot_connectome_strength( adj, node_coords=coordinates, cmap="YlGnBu", axes=ax2 ) return pval, adj, fig
def parcellation_data(): """Fixture for parcellations.""" parcels_tmp = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz') labels = pd.DataFrame({"label": list(map("label_{}".format, range(16)))})['label'].values.tolist() parcellation = data_gen.generate_labeled_regions((7, 6, 5), 16) parcels = parcellation.get_fdata() net_parcels_map_nifti_file = str(parcels_tmp.name) parcellation.to_filename(net_parcels_map_nifti_file) [coords, indices] = find_parcellation_cut_coords(parcellation, 0, return_label_names=True) coords = list(tuple(x) for x in coords) yield { 'net_parcels_map_nifti_file': net_parcels_map_nifti_file, 'parcels': parcels, 'labels': labels, 'coords': coords, 'indices': indices } parcels_tmp.close()
memory='nilearn_cache') # extract time series from all subjects and concatenate them time_series = [] for func, confounds in zip(data.func, data.confounds): time_series.append(masker.fit_transform(func, confounds=confounds)) # calculate correlation matrices across subjects and display correlation_matrices = connectome_measure.fit_transform(time_series) # Mean correlation matrix across 10 subjects can be grabbed like this, # using connectome measure object mean_correlation_matrix = connectome_measure.mean_ # grab center coordinates for atlas labels coordinates = plotting.find_parcellation_cut_coords(labels_img=yeo['thick_17']) # plot connectome with 80% edge strength in the connectivity plotting.plot_connectome(mean_correlation_matrix, coordinates, edge_threshold="80%", title='Yeo Atlas 17 thick (func)') ########################################################################## # Plot a directed connectome - asymmetric connectivity measure # ----------------------------------------------------------------- # In this section, we use the lag-1 correlation as the connectivity # measure, which leads to an asymmetric connectivity matrix. # The plot_connectome function accepts both symmetric and asymmetric # matrices, but plot the latter as a directed graph. import numpy as np
sig["Male students, post: {0}, phys retr".format(iq)] = np.max(p[0]) p, t, _ = permuted_ols( all_data["delta{0}".format(iq)].values, all_data[conns].values, all_data[["Age", "Mod", "Strt.Level", "post phys retr fd"]].values, ) sig["Male students, delta: {0}, phys retr".format(iq)] = np.max(p[0]) # - for key in sig.keys(): if sig[key] >= 1: print(key, sig[key]) coordinates = find_parcellation_cut_coords( labels_img= "/Users/Katie/Dropbox/Data/templates/shen2015/shen_triplenetwork.nii.gz") # + sig_f = {"PRI": ["pre rest", f_rest_pre]} for key in sig_f.keys(): f_conns = sig_f[key][1] iq = key task = sig_f[key][0] print(iq, task) all_data = pd.concat([big_df, f_conns], axis=1) all_data.dropna(how="any", axis=0, inplace=True) conns = list(set(f_conns.columns))
'/*.nii.gz')) #sort to irr0..19, pse0..19, reg0..19 betas_per_roi = extract_region_values( files, cc200_path ) #get mean beta value per roi for each stimulus [200,60] subj = hf.create_group('/visit2/' + sub_id) subj.create_dataset('betas_rois', data=betas_per_roi) if __name__ == '__main__': v1_path = '/usr/share/datasets/SCHOOLS/SCHBNOVO/BETAS_7s/' v2_path = '/usr/share/datasets/acerta_data/acerta_TASK/SCHOOLS_Betas/visit2/' v1_folders = glob(v1_path + 'betas*') v2_folders = glob(v2_path + '*') cc200_path = '/home/marcon/datasets/acerta_data/Masks/shen_1mm_268_resampled.nii.gz' cc200_coords = plotting.find_parcellation_cut_coords(labels_img=cc200_path) hf = h5py.File('betas_new_data.hdf5', 'w') hf.create_dataset('coordinates', data=cc200_coords) g1 = hf.create_group('visit1') g2 = hf.create_group('visit2') #store visit1 values for subject_folder in v1_folders: sub_id = subject_folder.split('_')[-1] print("Processing subject: ", sub_id) files = sorted(glob(subject_folder + '/*.nii')) #sort to irr0..19, pse0..19, reg0..19 betas_per_roi = extract_region_values( files, cc200_path ) #get mean beta value per roi for each stimulus [200,60]
@author: Or Duek Check Aging data connectivity """ import os import pandas as pd from nilearn import plotting from connUtils import removeVars, timeSeriesSingle, createCorMat ## set atlas (Here I use Yeo, but can use Shen or any other) atlas_filename = '/home/or/Downloads/1000subjects_reference_Yeo/Yeo_JNeurophysiol11_SplitLabels/MNI152/Yeo2011_17Networks_N1000.split_components.FSL_MNI152_1mm.nii.gz' atlas_labes = pd.read_csv( '/home/or/Downloads/1000subjects_reference_Yeo/Yeo_JNeurophysiol11_SplitLabels/Yeo2011_17networks_N1000.split_components.glossary.csv' ) coords = coords = plotting.find_parcellation_cut_coords( labels_img=atlas_filename) # take one subjects file # for this one I use the AROMA non aggresive one, as it is already "cleanded" (i.e. no need to remove confounds) func_file = '/media/Data/Aging/Preprocessed_data/aging_output/fmriprep/sub-010/ses-1/func/sub-010_ses-1_task-rest_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz' confound_file = '/media/Data/Aging/Preprocessed_data/aging_output/fmriprep/sub-010/ses-1/func/sub-010_ses-1_task-rest_desc-confounds_regressors.tsv' timeSer = timeSeriesSingle(func_file, confound_file, atlas_filename) from nilearn.connectome import ConnectivityMeasure correlation_measure = ConnectivityMeasure( kind='correlation') # can choose partial - it might be better correlation_matrix = correlation_measure.fit_transform([timeSer])[0] plotting.plot_matrix(correlation_matrix) plotting.plot_connectome(correlation_matrix,
import pickle import time import re import pandas as pd import glob from nilearn import plotting # Import function os.chdir( '/Users/senna/course/Mladen/project/pro3/BiometrikaRevision/simu/realdata') # import label and coordinate Lab = pd.read_csv(os.getcwd() + '/data/Output/labels.csv', index_col=0)['0'].tolist()[1:] f = open(os.getcwd() + '/data/atlas.txt', "r") atlas = f.read().splitlines()[0] Coor = plotting.find_parcellation_cut_coords(labels_img=atlas) f.close() # load our result mySparse = pd.read_csv(os.getcwd() + '/mymethod/MyResult/mySparse.csv', index_col=0).values ################################# ########### Plot ############ ################################# # show brain # plot connectome with 80% edge strength in the connectivity fig = plotting.plot_connectome(mySparse, Coor,
def AtlasParcellation(path, is_probabilistic=False): if is_probabilistic: return plotting.find_probabilistic_atlas_cut_coords(maps_img=path) else: return plotting.find_parcellation_cut_coords(labels_img=path)
########################################################################## # Iterate over fetched atlases to extract coordinates # --------------------------------------------------- for name, (atlas, threshold) in sorted(atlases_and_thresholds.items()): # create masker to extract functional data within atlas parcels masker = NiftiLabelsMasker(labels_img=atlas, standardize=True, memory='nilearn_cache') # extract time series from all subjects and concatenate them time_series = [] for func, confounds in zip(data.func, data.confounds): time_series.append(masker.fit_transform(func, confounds=confounds)) time_series = np.concatenate(time_series) # calculate correlation matrix and display correlation_matrix = np.corrcoef(time_series.T) # grab center coordinates for atlas labels coordinates = plotting.find_parcellation_cut_coords(atlas) # plot connectome plotting.plot_connectome(correlation_matrix, coordinates, edge_threshold=threshold, title=name) plotting.show()
for jj in range(0,len(idlist)): allfd[jj] = allsubjdenoised.meanFD[np.where(allsubjdenoised.participant_id==idlist[jj])[0]] for jj in range(0, len(lowertri[0])): pearsonobj = sp.stats.pearsonr(allfd,graphs[:,lowertri[0][jj],lowertri[1][jj]]) qcfc_fdr[ii,lowertri[0][jj],lowertri[1][jj]] = pearsonobj[0] qcfc_fdp[ii,lowertri[0][jj],lowertri[1][jj]] = pearsonobj[1] qcfc_fdr[ii,:,:] = qcfc_fdr[ii,:,:] + qcfc_fdr[ii,:,:].transpose() qcfc_fdp[ii,:,:] = qcfc_fdp[ii,:,:] + qcfc_fdp[ii,:,:].transpose() qcfc_fdm[ii] = np.nanmedian(qcfc_fdr[ii,:,:]) qcfc_fdq[ii] = np.sum(qcfc_fdp[ii,]<pthr) / np.prod(qcfc_fdp[ii,].shape) * 100 ##--- QC-FC distance-dependence (per Parkes et al., 2018; NeuroImage) if atlasis4d: atlas_region_coords = plotting.find_probabilistic_atlas_cut_coords(atlas) else: atlas_region_coords = plotting.find_parcellation_cut_coords(atlas) alldists = np.zeros((atlas_region_coords.shape[0],atlas_region_coords.shape[0])) for jj in range(0, len(atlas_region_coords)): for kk in range(0, len(atlas_region_coords)): alldists[jj,kk] = np.linalg.norm(atlas_region_coords[jj,]-atlas_region_coords[kk,]) qcfc = np.tril(np.mean(graphs,axis=0),-1).ravel() dist = np.tril( alldists,-1).ravel() qcfc = np.delete(qcfc, np.where(qcfc==0)) dist = np.delete(dist, np.where(dist==0)) spearmanobj = sp.stats.spearmanr(a=dist,b=qcfc,nan_policy='omit') qcfc_ddr[ii] = spearmanobj.correlation qcfc_ddp[ii] = spearmanobj.pvalue ##--- QC-FC association with temporal degrees of freedom loss tdof_lsm[ii] = np.mean(allsubjdenoised.PctDFlost) * 100 tdof_lsv[ii] = np.std(allsubjdenoised.PctDFlost) * 100
hf.close() print("Done.") if __name__ == '__main__': data_path = '/home/marcon/datasets/acerta_data/' visit1_paths = glob(data_path + 'acerta_RST/SCHOOLS/visit1/' + '*nii.gz') visit2_paths = glob(data_path + 'acerta_RST/SCHOOLS/visit2/' + '*nii.gz') output_filename = 'RST_timeseries_pruned.hdf5' mask_path = data_path + 'Masks/HaskinsPeds_NL_template_3x3x3_maskRESAMPLED.nii' atlas_path = data_path + 'Masks/HaskinsPeds_NL_atlasRESAMPLED1.0.nii' shen268_path = data_path + 'Masks/shen_1mm_268_resampled.nii.gz' shen268_coords = plotting.find_parcellation_cut_coords( labels_img=shen268_path) ts1 = get_region_timeseries(visit1_paths, shen268_path) ts2 = get_region_timeseries(visit2_paths, shen268_path) pruned_ts1, pruned_ts2 = prune_timeseries(ts1, ts2) # print("Computing correlation matrices") # cn_mx1 = get_correlation_matrix(ts1) # cn_mx2 = get_correlation_matrix(ts2) create_hd5(visit1_paths, visit2_paths, pruned_ts1, pruned_ts2, shen268_coords, output_filename) # create_hd5(visit1_paths,visit2_paths,cn_mx1,cn_mx2,shen268_coords)
import nilearn import numpy as np import pylab as plt import scipy.io as sio from nilearn import plotting # load connectome hagmann 2008 data --------------------------------- mat_cont = sio.loadmat("matfile/hagmann_998.mat") C = mat_cont['CIJ_fbden_average'] L = mat_cont['CIJ_edgelength_average'] xyz = mat_cont['talairach'] # get atlas data ---------------------------------------------------- destrieux = nilearn.datasets.fetch_atlas_destrieux_2009() coordinates, int_labels = plotting.find_parcellation_cut_coords( destrieux['maps'], return_label_names=True) print(coordinates.shape) # (148, 3) print(len(int_labels)) # 143 np.savetxt("data/destrieux_2009_coordinates.txt", coordinates, fmt="%18.9f") # extracting labels of each resion ---------------------------------- labels_int_string = [[ destrieux.labels[i][0], destrieux.labels[i][1].decode('UTF-8') ] for i in range(1, len(destrieux.labels))] ofile = open("data/destrieux_2009_labels.txt", "w") int_labels_dest = [ destrieux.labels[j][0] for j in range(len(destrieux.labels)) ] my_list = []
def get_mni_node_coordinates(self): """Retrieve node coordinates in MNI space from MNI parcellated brain """ image = nib.load(self.parcellated_image_path) self.coordinates = plotting.find_parcellation_cut_coords(image)
def structural_plotting(conn_matrix, uatlas, streamlines_mni, template_mask, interactive=False): """ :param conn_matrix: :param uatlas: :param streamlines_mni: :param template_mask: :param interactive: :return: """ import nibabel as nib import numpy as np import networkx as nx import os import pkg_resources from nibabel.affines import apply_affine from fury import actor, window, colormap, ui from dipy.tracking.utils import streamline_near_roi from nilearn.plotting import find_parcellation_cut_coords from nilearn.image import resample_to_img from pynets.thresholding import normalize from pynets.nodemaker import mmToVox ch2better_loc = pkg_resources.resource_filename( "pynets", "templates/ch2better.nii.gz") # Instantiate scene r = window.Renderer() # Set camera r.set_camera(position=(-176.42, 118.52, 128.20), focal_point=(113.30, 128.31, 76.56), view_up=(0.18, 0.00, 0.98)) # Load atlas rois atlas_img = nib.load(uatlas) atlas_img_data = atlas_img.get_data() # Collapse list of connected streamlines for visualization streamlines = nib.streamlines.load(streamlines_mni).streamlines parcels = [] i = 0 for roi in np.unique(atlas_img_data)[1:]: parcels.append(atlas_img_data == roi) i = i + 1 # Add streamlines as cloud of 'white-matter' streamlines_actor = actor.line(streamlines, colormap.create_colormap(np.ones( [len(streamlines)]), name='Greys_r', auto=True), lod_points=10000, depth_cue=True, linewidth=0.2, fake_tube=True, opacity=1.0) r.add(streamlines_actor) # Creat palette of roi colors and add them to the scene as faint contours roi_colors = np.random.rand(int(np.max(atlas_img_data)), 3) parcel_contours = [] i = 0 for roi in np.unique(atlas_img_data)[1:]: include_roi_coords = np.array(np.where(atlas_img_data == roi)).T x_include_roi_coords = apply_affine(np.eye(4), include_roi_coords) bool_list = [] for sl in streamlines: bool_list.append( streamline_near_roi(sl, x_include_roi_coords, tol=1.0, mode='either_end')) if sum(bool_list) > 0: print('ROI: ' + str(i)) parcel_contours.append( actor.contour_from_roi(atlas_img_data == roi, color=roi_colors[i], opacity=0.2)) else: pass i = i + 1 for vol_actor in parcel_contours: r.add(vol_actor) # Get voxel coordinates of parcels and add them as 3d spherical centroid nodes [coords, labels] = find_parcellation_cut_coords(atlas_img, background_label=0, return_labels=True) coords_vox = [] for i in coords: coords_vox.append(mmToVox(atlas_img.affine, i)) coords_vox = list(set(list(tuple(x) for x in coords_vox))) # Build an edge list of 3d lines G = nx.from_numpy_array(normalize(conn_matrix)) for i in G.nodes(): nx.set_node_attributes(G, {i: coords_vox[i]}, labels[i]) G.remove_nodes_from(list(nx.isolates(G))) G_filt = nx.Graph() fedges = filter(lambda x: G.degree()[x[0]] > 0 and G.degree()[x[1]] > 0, G.edges()) G_filt.add_edges_from(fedges) coord_nodes = [] for i in range(len(G.edges())): edge = list(G.edges())[i] [x, y] = edge x_coord = list(G.nodes[x].values())[0] x_label = list(G.nodes[x].keys())[0] l_x = actor.label(text=str(x_label), pos=x_coord, scale=(1, 1, 1), color=(50, 50, 50)) r.add(l_x) y_coord = list(G.nodes[y].values())[0] y_label = list(G.nodes[y].keys())[0] l_y = actor.label(text=str(y_label), pos=y_coord, scale=(1, 1, 1), color=(50, 50, 50)) r.add(l_y) coord_nodes.append(x_coord) coord_nodes.append(y_coord) c = actor.line([(x_coord, y_coord)], window.colors.coral, linewidth=100 * (float(G.get_edge_data(x, y)['weight'])) ^ 2) r.add(c) point_actor = actor.point(list(set(coord_nodes)), window.colors.grey, point_radius=0.75) r.add(point_actor) # Load glass brain template and resample to MNI152_2mm brain template_img = nib.load(ch2better_loc) template_target_img = nib.load(template_mask) res_brain_img = resample_to_img(template_img, template_target_img) template_img_data = res_brain_img.get_data().astype('bool') template_actor = actor.contour_from_roi(template_img_data, color=(50, 50, 50), opacity=0.05) r.add(template_actor) # Show scene if interactive is True: window.show(r, size=(600, 600), reset_camera=False) else: fig_path = os.path.dirname(streamlines_mni) + '/3d_connectome_fig.png' window.record(r, out_path=fig_path, size=(600, 600)) return
# # vol_actor.AddObserver('LeftButtonPressEvent', # # point_left_click_callback, # # 1.0) # scene.add(vol_actor) # Load glass brain template and resample to MNI152_2mm brain template_img = nib.load(ch2bet) template_target_img = nib.load(ch2bet_target) res_brain_img = resample_to_img(template_img, template_target_img) template_img_data = res_brain_img.get_data().astype('bool') template_actor = actor.contour_from_roi(template_img_data, color=(50, 50, 50), opacity=0.05) scene.add(template_actor) visible_callback.brain_actor = template_actor # Get voxel coordinates of parcels and add them as 3d spherical centroid nodes [coords, label_names] = find_parcellation_cut_coords(atlas_img, background_label=0, return_label_names=True) coords_vox = [] for i in coords: coords_vox.append(mmToVox(atlas_img, i)) coords_vox = list(set(list(tuple(x) for x in coords_vox))) # Build an edge list of 3d lines df = pd.read_csv(graph_properties) node_cols = [s for s in list(df.columns) if isinstance(s, int) or any(c.isdigit() for c in s)] conn_matrix = np.load(conn_matrix_path) conn_matrix = normalize(conn_matrix) G = nx.from_numpy_array(conn_matrix) # Add adj. mat
memory='nilearn_cache') # extract time series from all subjects and concatenate them time_series = [] for func, confounds in zip(data.func, data.confounds): time_series.append(masker.fit_transform(func, confounds=confounds)) # calculate correlation matrices across subjects and display correlation_matrices = connectome_measure.fit_transform(time_series) # Mean correlation matrix across 10 subjects can be grabbed like this, # using connectome measure object mean_correlation_matrix = connectome_measure.mean_ # grab center coordinates for atlas labels coordinates = plotting.find_parcellation_cut_coords(labels_img=yeo['thick_17']) # plot connectome with 80% edge strength in the connectivity plotting.plot_connectome(mean_correlation_matrix, coordinates, edge_threshold="80%", title='Yeo Atlas 17 thick (func)') ########################################################################## # Load probabilistic atlases - extracting coordinates on brain maps # ----------------------------------------------------------------- msdl = datasets.fetch_atlas_msdl() ########################################################################## # Iterate over fetched atlases to extract coordinates - probabilistic # -------------------------------------------------------------------
"fd", ] index = pd.MultiIndex.from_product([masks.keys(), tasks.keys(), variables]) sig = pd.DataFrame(index=index) # running each permuted OLS regression this many times n_perm = 10000 # creating figures automatically for regressions with significant edges node_size = 10 # run all regressions for all task-IQ combos once for each parcellation for mask in masks.keys(): # for making connectome figures, read in the relevant parcellation mask_nii = masks[mask] # and extract coordinates per node/region coords = find_parcellation_cut_coords(labels_img=mask_nii) # run regressions per task, only reading in all subjects' corrmats # done separately for each task & condition and removing in between bc memory for task in tasks.keys(): # only testing IQs associated with accuracy on this task iqs = tasks[task]["iqs"] # read in all subjects' correlation matrices and flatten into feature vectors conn_df = corrmat_to_samples_by_features(subjects, 1, task, "Physics", mask, tau) conn_df.index = conn_df.index.astype(int) conns = list(set(conn_df.columns)) # smush connectivity features and other variables into one big dataframe all_data = pd.concat([big_df, conn_df], axis=1)