def test_loc_eff_bin(): x = load_sample(thres=.4) leff = bct.efficiency_bin(x, local=True) y = bct.binarize(x) leff2 = bct.efficiency_bin(y, local=True) print(np.sum(leff), np.sum(leff2), 105.5111) assert np.allclose(np.sum(leff), 105.5111, atol=0.1) assert np.allclose(np.sum(leff2), 105.5111, atol=0.1)
def test_glob_eff_bin(): x = load_sample(thres=.4) geff = bct.efficiency_bin(x) y = bct.binarize(x) geff2 = bct.efficiency_bin(y) print(geff, geff2, 0.6999) assert np.allclose(geff, 0.6999, atol=1e-4) assert np.allclose(geff2, 0.6999, atol=1e-4)
def calculate_path_and_efficiency_bin(G): """ Return the following network metrics for your graph. Uses brain connectivity tool-box. Input: G (np.array): binarized matrix, symmetric Outputs: Eglob: Global efficiency average_Elocal: mean Local Efficiency char_path: Average shortest path length clustering: Average Clustering coefficient """ if not np.allclose(G, G.T): raise bct.BCTParamError('Not undirected') average_shortest_path, Eglob, _, _, _ = bct.charpath(bct.distance_bin(G)) average_clustering = np.mean(abs(bct.clustering_coef_bu(G))) average_Elocal = np.mean(bct.efficiency_bin(G, 1)) return Eglob, average_Elocal, average_clustering, average_shortest_path
10 34 14 34 15 34 16 34 19 34 20 34 21 34 23 34 24 34 27 34 28 34 29 34 30 34 31 34 32 34 33 34 """.strip() arr = np.zeros((34, 34), dtype=np.uint8) for row in s.split('\n'): first, second = row.split(' ') arr[int(first) - 1, int(second) - 1] += 1 arr = bct.binarize(arr + arr.T) np.random.seed(1991) eff = bct.efficiency_bin(arr) mod = bct.modularity_und(arr) rand = bct.randmio_und_connected(arr, 5)
return np.where(CIJ[i] > 0)[0] def min_hop_count(CIJ): mhc = bct.distance_bin(CIJ) mhc[mhc == 0] = np.Inf return mhc def network_of_neighbours(CIJ, i): neighbours = np.where(CIJ[i] > 0)[0] return CIJ[neighbours][:, neighbours] N = int(sys.argv[1]) k = int(sys.argv[2]) p = float(sys.argv[3]) net = NetworkWattsStrogatz(N, k, p) print("BrainConnectivityToolbox...\n") print("\tEff[Global] = " + str(bct.efficiency_bin(net))) print("\tEff[Local] = " + str(bct.efficiency_bin(net, local=True))) print("\n\nHomebrew...\n") print("\tEff[Global] = " + str(global_eff(net))) print("\tEff[Local] = " + str(local_eff(net))) PlotConnectivity(net)
def threshold_global_cost_efficiency(mtx, iterations): """ Threshold a graph based on the Global Efficiency - Cost formula. .. [Basset2009] Bassett, D. S., Bullmore, E. T., Meyer-Lindenberg, A., Apud, J. A., Weinberger, D. R., & Coppola, R. (2009). Cognitive fitness of cost-efficient brain functional networks. Proceedings of the National Academy of Sciences, 106(28), 11747-11752. Parameters ---------- mtx : array-like, shape(N, N) Symmetric, weighted and undirected connectivity matrix. iterations : int Number of steps, as a resolution when search for optima. Returns ------- binary_mtx : array-like, shape(N, N) A binary mask matrix. threshold : float The threshold that maximizes the global cost efficiency. global_cost_eff_max : float Global cost efficiency. efficiency : float Global efficiency. cost_max : float Cost of the network at the maximum global cost efficiency """ binary_mtx = np.zeros_like(mtx, dtype=np.int32) step = 1.0 / iterations thresholds = np.arange(0, 1 + step, step) N, _ = np.shape(mtx) num_connections = (N * (N - 1)) / 2.0 global_cost_eff = np.zeros((iterations, 1)) cost = np.zeros((iterations, 1)) for i in range(iterations): tmp_binary = np.zeros_like(binary_mtx) for k in range(N): for l in range(k + 1, N): if mtx[k, l] > thresholds[i]: tmp_binary[k, l] = 1 tmp_binary[l, k] = 1 global_eff = bct.efficiency_bin(tmp_binary) degree = bct.degrees_und(tmp_binary) total_degree = np.sum(degree) cost[i] = (0.5 * total_degree) / num_connections global_cost_eff[i] = global_eff - cost[i] indx_max = np.argmax(global_cost_eff) threshold = thresholds[indx_max] for k in range(N): for l in range(k + 1, N): if mtx[k, l] >= threshold: binary_mtx[k, l] = 1 binary_mtx[l, k] = 1 cost_max = cost[indx_max] global_cost_eff_max = global_cost_eff[indx_max] efficiency = bct.efficiency_bin(binary_mtx) # import matplotlib.pyplot as plt # plt.figure() # plt.plot(cost, global_cost_eff) # plt.plot(cost_max, global_cost_eff_max, 'b*', label='Max Global Cost Efficiency') # plt.title('Economical small-world network at max Global Cost Efficiency') # plt.xlabel('Cost') # plt.ylabel('Global Cost Efficiency') # plt.legend() # plt.show() return binary_mtx, threshold, global_cost_eff_max, efficiency, cost_max