def perform_thresholding(conn_matrix, thr, min_span_tree, dens_thresh, disp_filt): """ References ---------- .. [1] Fornito, A., Zalesky, A., & Bullmore, E. T. (2016). Fundamentals of Brain Network Analysis. In Fundamentals of Brain Network Analysis. https://doi.org/10.1016/C2012-0-06036-X """ import numpy as np import networkx as nx from pynets.core import thresholding thr_perc = 100 - np.abs(100 * float(thr)) if min_span_tree is True: print("Using local thresholding from the " "Minimum Spanning Tree (MST)...\n") if dens_thresh is True: print("Ignoring -dt flag since local density thresholding is not" " currently supported.") thr_type = "MST" edge_threshold = f"{str(thr_perc)}%" conn_matrix_thr = thresholding.local_thresholding_prop( conn_matrix, thr) elif disp_filt is True: thr_type = "DISPARITY" edge_threshold = f"{str(thr_perc)}%" G1 = thresholding.disparity_filter( nx.from_numpy_array(np.abs(conn_matrix))) print(f"Computing edge disparity significance with alpha = {thr}") print(f"Filtered graph: nodes = {G1.number_of_nodes()}, " f"edges = {G1.number_of_edges()}") conn_matrix_bin = thresholding.binarize( nx.to_numpy_array(G1, nodelist=sorted(G1.nodes()), dtype=np.float64)) # Enforce original dimensionality by padding with zeros. conn_matrix_thr = np.multiply(conn_matrix, conn_matrix_bin) else: if dens_thresh is False: thr_type = "PROP" edge_threshold = f"{str(thr_perc)}{'%'}" print(f"\nThresholding proportionally at: {thr_perc}% ...\n") conn_matrix_thr = thresholding.threshold_proportional( conn_matrix, float(thr)) else: thr_type = "DENS" edge_threshold = None print(f"\nThresholding to achieve density of: {thr_perc}% ...\n") conn_matrix_thr = thresholding.density_thresholding( conn_matrix, float(thr)) return thr_type, edge_threshold, conn_matrix_thr
def plot_conn_mat(conn_matrix, labels, out_path_fig, cmap, binarized=False, dpi_resolution=300): """ Plot a connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig : str File path to save the connectivity matrix image as a .png figure. """ import matplotlib matplotlib.use("agg") from matplotlib import pyplot as plt from nilearn.plotting import plot_matrix from pynets.core import thresholding import matplotlib.ticker as mticker conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=np.min(conn_matrix_plt) - 0.000001, reorder="average", auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") if len(labels) > 40: tick_interval = int(np.around(len(labels) / 40)) else: tick_interval = int(np.around(len(labels))) plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.savefig(out_path_fig, dpi=dpi_resolution) plt.close() return
def test_weighted_transitivity(binarize): """ Test weighted_transitivity computation """ from pynets.core.thresholding import binarize base_dir = str(Path(__file__).parent/"examples") est_path = f"{base_dir}/miscellaneous/sub-0021001_rsn-Default_nodetype-parc_model-sps_template-MNI152_T1_thrtype-DENS_thr-0.19.npy" in_mat = np.load(est_path) if binarize: in_mat = binarize(in_mat) G = nx.from_numpy_array(in_mat) transitivity = netstats.weighted_transitivity(G) assert transitivity <= 3 assert transitivity >= 0
def plot_conn_mat(conn_matrix, labels, out_path_fig, cmap, dpi_resolution=300): """ Plot a connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig : str File path to save the connectivity matrix image as a .png figure. """ import matplotlib matplotlib.use("agg") from matplotlib import pyplot as plt from nilearn.plotting import plot_matrix from pynets.core import thresholding conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.abs(np.max(conn_matrix_plt)), vmin=-np.abs(np.max(conn_matrix_plt)), reorder="average", auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") plt.savefig(out_path_fig, dpi=dpi_resolution) plt.close() return
def test_binarize(x, thr, cp): y = thresholding.threshold_proportional(x, thr, copy=cp) s = thresholding.binarize(y) assert np.sum(s) == np.count_nonzero(y)
def plot_community_conn_mat(conn_matrix, labels, out_path_fig_comm, community_aff, cmap, dpi_resolution=300): """ Plot a community-parcellated connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig_comm : str File path to save the community-parcellated connectivity matrix image as a .png figure. community_aff : array Community-affiliation vector. """ import warnings warnings.filterwarnings("ignore") from matplotlib import pyplot as plt matplotlib.use("agg") import mplcyberpunk plt.style.use("cyberpunk") import matplotlib.patches as patches import matplotlib.ticker as mticker matplotlib.use("agg") from nilearn.plotting import plot_matrix from pynets.core import thresholding plt.style.use("cyberpunk") conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) sorting_array = sorted(range(len(community_aff)), key=lambda k: community_aff[k]) sorted_conn_matrix = conn_matrix[sorting_array, :] sorted_conn_matrix = sorted_conn_matrix[:, sorting_array] rois_num = sorted_conn_matrix.shape[0] if rois_num < 100: try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=0, reorder=False, auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") else: try: plot_matrix( conn_matrix_plt, figure=(10, 10), vmax=np.abs(np.max(conn_matrix_plt)), vmin=0, auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") ax = plt.gca() total_size = 0 for community in np.unique(community_aff): size = sum(sorted(community_aff) == community) ax.add_patch( patches.Rectangle( (total_size, total_size), size, size, fill=False, edgecolor="white", alpha=None, linewidth=1, )) total_size += size if len(labels) > 500: tick_interval = 5 elif len(labels) > 100: tick_interval = 4 elif len(labels) > 50: tick_interval = 2 else: tick_interval = 1 plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) for param in ['figure.facecolor', 'axes.facecolor', 'savefig.facecolor']: plt.rcParams[param] = '#000000' plt.savefig(out_path_fig_comm, dpi=dpi_resolution) plt.close() return
def plot_conn_mat(conn_matrix, labels, out_path_fig, cmap, binarized=False, dpi_resolution=300): """ Plot a connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig : str File path to save the connectivity matrix image as a .png figure. """ import warnings warnings.filterwarnings("ignore") import matplotlib import mplcyberpunk from matplotlib import pyplot as plt matplotlib.use("agg") plt.style.use("cyberpunk") from matplotlib import pyplot as plt from nilearn.plotting import plot_matrix from pynets.core import thresholding import matplotlib.ticker as mticker conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=0, reorder="average", auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") if len(labels) > 500: tick_interval = 5 elif len(labels) > 100: tick_interval = 4 elif len(labels) > 50: tick_interval = 2 else: tick_interval = 1 plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) for param in ['figure.facecolor', 'axes.facecolor', 'savefig.facecolor']: plt.rcParams[param] = '#000000' plt.savefig(out_path_fig, dpi=dpi_resolution) plt.close() return
def plot_community_conn_mat(conn_matrix, labels, out_path_fig_comm, community_aff, cmap, dpi_resolution=300): """ Plot a community-parcellated connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig_comm : str File path to save the community-parcellated connectivity matrix image as a .png figure. community_aff : array Community-affiliation vector. """ import warnings warnings.filterwarnings("ignore") import sys import pkg_resources import yaml import matplotlib import matplotlib.pyplot as plt import matplotlib.patches as patches import matplotlib.ticker as mticker matplotlib.use("agg") from nilearn.plotting import plot_matrix from pynets.core import thresholding conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) try: with open(pkg_resources.resource_filename("pynets", "runconfig.yaml"), "r") as stream: hardcoded_params = yaml.load(stream) try: labeling_atlas = \ hardcoded_params["plotting"]["labeling_atlas"][0] except KeyError: print( "ERROR: Plotting configuration not successfully extracted" " from runconfig.yaml") sys.exit(0) stream.close() labels = [i[0][labeling_atlas] for i in labels] except BaseException: pass sorting_array = sorted(range(len(community_aff)), key=lambda k: community_aff[k]) sorted_conn_matrix = conn_matrix[sorting_array, :] sorted_conn_matrix = sorted_conn_matrix[:, sorting_array] rois_num = sorted_conn_matrix.shape[0] if rois_num < 100: try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=0, reorder=False, auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") else: try: plot_matrix( conn_matrix_plt, figure=(10, 10), vmax=np.abs(np.max(conn_matrix_plt)), vmin=0, auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") ax = plt.gca() total_size = 0 for community in np.unique(community_aff): size = sum(sorted(community_aff) == community) ax.add_patch( patches.Rectangle( (total_size, total_size), size, size, fill=False, edgecolor="black", alpha=None, linewidth=1, )) total_size += size tick_interval = int(np.around(len(labels))) / 20 plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.savefig(out_path_fig_comm, dpi=dpi_resolution) plt.close() return
def plot_conn_mat(conn_matrix, labels, out_path_fig, cmap, binarized=False, dpi_resolution=300): """ Plot a connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig : str File path to save the connectivity matrix image as a .png figure. """ import warnings warnings.filterwarnings("ignore") import matplotlib matplotlib.use("agg") import sys import pkg_resources import yaml from matplotlib import pyplot as plt from nilearn.plotting import plot_matrix from pynets.core import thresholding import matplotlib.ticker as mticker conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) try: with open(pkg_resources.resource_filename("pynets", "runconfig.yaml"), "r") as stream: hardcoded_params = yaml.load(stream) try: labeling_atlas = \ hardcoded_params["plotting"]["labeling_atlas"][0] except KeyError: print( "ERROR: Plotting configuration not successfully extracted" " from runconfig.yaml") sys.exit(0) stream.close() labels = [i[0][labeling_atlas] for i in labels] except BaseException: pass try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=0, reorder="average", auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") tick_interval = int(np.around(len(labels))) / 20 plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.savefig(out_path_fig, dpi=dpi_resolution) plt.close() return
def perform_thresholding(conn_matrix, coords, labels, thr, thr_perc, min_span_tree, dens_thresh, disp_filt): from pynets.core import thresholding if min_span_tree is True: print( 'Using local thresholding option with the Minimum Spanning Tree (MST)...\n' ) if dens_thresh is True: print( 'Ignoring -dt flag since local density thresholding is not currently supported.' ) thr_type = 'MST_thr' edge_threshold = "%s%s" % (str(thr_perc), '%') [conn_matrix_thr, coords, labels ] = thresholding.local_thresholding_prop(conn_matrix, coords, labels, thr) elif disp_filt is True: thr_type = 'DISP_alpha' edge_threshold = "%s%s" % (str(thr_perc), '%') G1 = thresholding.disparity_filter( nx.from_numpy_array(np.abs(conn_matrix))) # G2 = nx.Graph([(u, v, d) for u, v, d in G1.edges(data=True) if d['alpha'] < thr]) print('Computing edge disparity significance with alpha = %s' % thr) print('Filtered graph: nodes = %s, edges = %s' % (G1.number_of_nodes(), G1.number_of_edges())) # print('Backbone graph: nodes = %s, edges = %s' % (G2.number_of_nodes(), G2.number_of_edges())) # print(G2.edges(data=True)) conn_matrix_bin = thresholding.binarize( nx.to_numpy_array(G1, nodelist=sorted(G1.nodes()), dtype=np.float64)) # Enforce original dimensionality by padding with zeros. if conn_matrix_bin.shape != conn_matrix.shape: if conn_matrix.shape[0] > conn_matrix_bin.shape[0]: result = np.zeros(conn_matrix.shape) result[:conn_matrix_bin.shape[0], :conn_matrix_bin. shape[1]] = conn_matrix_bin conn_matrix_thr = np.multiply(conn_matrix, result) else: result = np.zeros(conn_matrix_bin.shape) result[:conn_matrix.shape[0], :conn_matrix. shape[1]] = conn_matrix conn_matrix_thr = np.multiply(conn_matrix_bin, result) else: conn_matrix_thr = np.multiply(conn_matrix, conn_matrix_bin) else: if dens_thresh is False: thr_type = 'prop' edge_threshold = "%s%s" % (str(thr_perc), '%') print("%s%.2f%s" % ('\nThresholding proportionally at: ', thr_perc, '% ...\n')) conn_matrix_thr = thresholding.threshold_proportional( conn_matrix, float(thr)) else: thr_type = 'dens' edge_threshold = None print("%s%.2f%s" % ('\nThresholding to achieve density of: ', thr_perc, '% ...\n')) conn_matrix_thr = thresholding.density_thresholding( conn_matrix, float(thr)) return thr_type, edge_threshold, conn_matrix_thr, coords, labels
def local_thresholding_prop(conn_matrix, coords, labels, thr): """ Threshold the adjacency matrix by building from the minimum spanning tree (MST) and adding successive N-nearest neighbour degree graphs to achieve target proportional threshold. Parameters ---------- conn_matrix : array Weighted NxN matrix. thr : float A proportional threshold, between 0 and 1, to achieve through local thresholding. Returns ------- conn_matrix_thr : array Weighted, MST local-thresholded, NxN matrix. """ from pynets.core import thresholding from pynets.stats import netstats fail_tol = 100 conn_matrix = np.nan_to_num(conn_matrix) G = nx.from_numpy_matrix(np.abs(conn_matrix)) if not nx.is_connected(G): [G, pruned_nodes] = netstats.prune_disconnected(G) pruned_nodes.sort(reverse=True) coords_pre = list(coords) labels_pre = list(labels) if len(pruned_nodes) > 0: for j in pruned_nodes: labels_pre.pop(j) coords_pre.pop(j) conn_matrix = nx.to_numpy_array(G) labels = labels_pre coords = coords_pre maximum_edges = G.number_of_edges() min_t = nx.minimum_spanning_tree(thresholding.weight_to_distance(G), weight="distance") len_edges = min_t.number_of_edges() upper_values = np.triu_indices(np.shape(conn_matrix)[0], k=1) weights = np.array(conn_matrix[upper_values]) edgenum = int(float(thr) * float(len(weights[~np.isnan(weights)]))) if len_edges > edgenum: print("%s%s%s" % ( 'Warning: The minimum spanning tree already has: ', len_edges, ' edges, select more edges. Local Threshold will be applied by just retaining the Minimum ' 'Spanning Tree')) conn_matrix_thr = nx.to_numpy_array(G) return conn_matrix_thr, coords, labels k = 1 len_edge_list = [] while len_edges < edgenum and k <= np.shape(conn_matrix)[0] and ( len(len_edge_list[-fail_tol:]) - len(set(len_edge_list[-fail_tol:]))) < (fail_tol - 1): # print(k) # print(len_edges) len_edge_list.append(len_edges) # Create nearest neighbour graph nng = thresholding.knn(conn_matrix, k) # Remove edges from the NNG that exist already in the new graph/MST nng.remove_edges_from(min_t.edges()) number_before = nng.number_of_edges() if nng.number_of_edges() == 0 and number_before >= maximum_edges: break # Add weights to NNG for e in nng.edges(): nng.edges[e[0], e[1]]['weight'] = float(conn_matrix[e[0], e[1]]) # Obtain list of edges from the NNG in order of weight edge_list = sorted(nng.edges(data=True), key=lambda t: t[2]['weight'], reverse=True) # Add edges in order of connectivity strength for edge in edge_list: # print("%s%s" % ('Adding edge to mst: ', edge)) min_t.add_edges_from([edge]) len_edges = min_t.number_of_edges() if len_edges >= edgenum: print(len_edges) break k += 1 conn_matrix_bin = thresholding.binarize( nx.to_numpy_array(min_t, nodelist=sorted(min_t.nodes()), dtype=np.float64)) # Enforce original dimensionality by padding with zeros. if conn_matrix_bin.shape != conn_matrix.shape: if conn_matrix.shape[0] > conn_matrix_bin.shape[0]: result = np.zeros(conn_matrix.shape) result[:conn_matrix_bin.shape[0], :conn_matrix_bin. shape[1]] = conn_matrix_bin conn_matrix_thr = np.multiply(conn_matrix, result) else: result = np.zeros(conn_matrix_bin.shape) result[:conn_matrix.shape[0], :conn_matrix.shape[1]] = conn_matrix conn_matrix_thr = np.multiply(conn_matrix_bin, result) else: conn_matrix_thr = np.multiply(conn_matrix, conn_matrix_bin) return conn_matrix_thr, coords, labels
def local_thresholding_prop(conn_matrix, thr): """ Threshold the adjacency matrix by building from the minimum spanning tree (MST) and adding successive N-nearest neighbour degree graphs to achieve target proportional threshold. Parameters ---------- conn_matrix : array Weighted NxN matrix. thr : float A proportional threshold, between 0 and 1, to achieve through local thresholding. Returns ------- conn_matrix_thr : array Weighted local-thresholding using MST, NxN matrix. References ---------- .. [1] Alexander-Bloch, A. F., Gogtay, N., Meunier, D., Birn, R., Clasen, L., Lalonde, F., … Bullmore, E. T. (2010). Disrupted modularity and local connectivity of brain functional networks in childhood-onset schizophrenia. Frontiers in Systems Neuroscience. https://doi.org/10.3389/fnsys.2010.00147 .. [2] Tewarie, P., van Dellen, E., Hillebrand, A., & Stam, C. J. (2015). The minimum spanning tree: An unbiased method for brain network analysis. NeuroImage. https://doi.org/10.1016/j.neuroimage.2014.10.015 """ from pynets.core import thresholding fail_tol = 100 conn_matrix = np.nan_to_num(conn_matrix) G = nx.from_numpy_matrix(np.abs(conn_matrix)) maximum_edges = G.number_of_edges() Gcc = sorted(nx.connected_components(G), key=len, reverse=True) G0 = G.subgraph(Gcc[0]) min_t = nx.minimum_spanning_tree(thresholding.weight_to_distance(G0), weight="distance") min_t.add_nodes_from(G.nodes()) len_edges = min_t.number_of_edges() upper_values = np.triu_indices(np.shape(conn_matrix)[0], k=1) weights = np.array(conn_matrix[upper_values]) edgenum = int(float(thr) * float(len(weights[~np.isnan(weights)]))) if len_edges > edgenum: print( f"Warning: The minimum spanning tree already has: {len_edges} edges, select more edges. Local Threshold " f"will be applied by just retaining the Minimum Spanning Tree") conn_matrix_thr = nx.to_numpy_array(G) return conn_matrix_thr k = 1 len_edge_list = [] while (len_edges < edgenum and k <= np.shape(conn_matrix)[0] and (len(len_edge_list[-fail_tol:]) - len(set(len_edge_list[-fail_tol:]))) < (fail_tol - 1)): # print(k) # print(len_edges) len_edge_list.append(len_edges) # Create nearest neighbour graph nng = thresholding.knn(conn_matrix, k) # Remove edges from the NNG that exist already in the new graph/MST nng.remove_edges_from(min_t.edges()) number_before = nng.number_of_edges() if nng.number_of_edges() == 0 and number_before >= maximum_edges: break # Add weights to NNG for e in nng.edges(): nng.edges[e[0], e[1]]["weight"] = float(conn_matrix[e[0], e[1]]) # Obtain list of edges from the NNG in order of weight edge_list = sorted(nng.edges(data=True), key=lambda t: t[2]["weight"], reverse=True) # Add edges in order of connectivity strength for edge in edge_list: # print(f"Adding edge to mst: {edge}") min_t.add_edges_from([edge]) len_edges = min_t.number_of_edges() if len_edges >= edgenum: # print(len_edges) break k += 1 conn_matrix_bin = thresholding.binarize( nx.to_numpy_array(min_t, nodelist=sorted(G.nodes()), dtype=np.float64)) try: conn_matrix_thr = np.multiply(conn_matrix, conn_matrix_bin) return conn_matrix_thr except ValueError: print( "MST thresholding failed. Check raw graph output manually for debugging." )
def plot_community_conn_mat(conn_matrix, labels, out_path_fig_comm, community_aff, cmap, dpi_resolution=300): """ Plot a community-parcellated connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig_comm : str File path to save the community-parcellated connectivity matrix image as a .png figure. community_aff : array Community-affiliation vector. """ import matplotlib import matplotlib.pyplot as plt import matplotlib.patches as patches matplotlib.use('agg') #from pynets import thresholding from nilearn.plotting import plot_matrix from pynets.core import thresholding conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) sorting_array = sorted(range(len(community_aff)), key=lambda k: community_aff[k]) sorted_conn_matrix = conn_matrix[sorting_array, :] sorted_conn_matrix = sorted_conn_matrix[:, sorting_array] rois_num = sorted_conn_matrix.shape[0] if rois_num < 100: try: plot_matrix(conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.abs(np.max(conn_matrix_plt)), vmin=-np.abs(np.max(conn_matrix_plt)), reorder=False, auto_fit=True, grid=False, colorbar=False, cmap=cmap) except RuntimeWarning: print('Connectivity matrix too sparse for plotting...') else: try: plot_matrix(conn_matrix_plt, figure=(10, 10), vmax=np.abs(np.max(conn_matrix_plt)), vmin=-np.abs(np.max(conn_matrix_plt)), auto_fit=True, grid=False, colorbar=False, cmap=cmap) except RuntimeWarning: print('Connectivity matrix too sparse for plotting...') ax = plt.gca() total_size = 0 for community in np.unique(community_aff): size = sum(sorted(community_aff) == community) ax.add_patch( patches.Rectangle((total_size, total_size), size, size, fill=False, edgecolor='black', alpha=None, linewidth=1)) total_size += size plt.savefig(out_path_fig_comm, dpi=dpi_resolution) plt.close() return
def binarize_graph(self): in_mat_bin = thresholding.binarize(self.in_mat) # Load numpy matrix as networkx graph G_bin = nx.from_numpy_array(in_mat_bin) return in_mat_bin, G_bin
def perform_thresholding(conn_matrix, thr, min_span_tree, dens_thresh, disp_filt): ''' References ---------- .. [1] Fornito, A., Zalesky, A., & Bullmore, E. T. (2016). Fundamentals of Brain Network Analysis. In Fundamentals of Brain Network Analysis. https://doi.org/10.1016/C2012-0-06036-X ''' import numpy as np import networkx as nx from pynets.core import thresholding thr_perc = 100 - np.abs(100 * float(thr)) if min_span_tree is True: print( 'Using local thresholding option with the Minimum Spanning Tree (MST)...\n' ) if dens_thresh is True: print( 'Ignoring -dt flag since local density thresholding is not currently supported.' ) thr_type = 'MST' edge_threshold = f"{str(thr_perc)}%" conn_matrix_thr = thresholding.local_thresholding_prop( conn_matrix, thr) elif disp_filt is True: thr_type = 'DISPARITY' edge_threshold = f"{str(thr_perc)}%" G1 = thresholding.disparity_filter( nx.from_numpy_array(np.abs(conn_matrix))) # G2 = nx.Graph([(u, v, d) for u, v, d in G1.edges(data=True) if d['alpha'] < thr]) print(f"Computing edge disparity significance with alpha = {thr}") print( f'Filtered graph: nodes = {G1.number_of_nodes()}, edges = {G1.number_of_edges()}' ) # print(f'Backbone graph: nodes = {G2.number_of_nodes()}, edges = {G2.number_of_edges()}") # print(G2.edges(data=True)) conn_matrix_bin = thresholding.binarize( nx.to_numpy_array(G1, nodelist=sorted(G1.nodes()), dtype=np.float64)) # Enforce original dimensionality by padding with zeros. if conn_matrix_bin.shape != conn_matrix.shape: if conn_matrix.shape[0] > conn_matrix_bin.shape[0]: result = np.zeros(conn_matrix.shape) result[:conn_matrix_bin.shape[0], :conn_matrix_bin. shape[1]] = conn_matrix_bin conn_matrix_thr = np.multiply(conn_matrix, result) else: result = np.zeros(conn_matrix_bin.shape) result[:conn_matrix.shape[0], :conn_matrix. shape[1]] = conn_matrix conn_matrix_thr = np.multiply(conn_matrix_bin, result) else: conn_matrix_thr = np.multiply(conn_matrix, conn_matrix_bin) else: if dens_thresh is False: thr_type = 'PROP' edge_threshold = f"{str(thr_perc)}{'%'}" print(f"\nThresholding proportionally at: {thr_perc}% ...\n") conn_matrix_thr = thresholding.threshold_proportional( conn_matrix, float(thr)) else: thr_type = 'DENS' edge_threshold = None print(f"\nThresholding to achieve density of: {thr_perc}% ...\n") conn_matrix_thr = thresholding.density_thresholding( conn_matrix, float(thr)) return thr_type, edge_threshold, conn_matrix_thr