Beispiel #1
0
def compute_metric_backbone(G):
    print('> Computing Dijkstra APSP')
    dict_edges = {(i, j): prox2dist(d['weight'])
                  for i, j, d in G.edges(data=True)}
    dij = Dijkstra.from_edgelist(dict_edges, directed=False, verbose=10)

    print('> Metric')
    poolresults = list(range(len(dij.N)))
    for node in dij.N:
        print('> Dijkstra node {node:d} of {n_nodes:d}'.format(node=node + 1,
                                                               n_nodes=len(
                                                                   dij.N)))
        poolresults[node] = _cy_single_source_shortest_distances(
            node, dij.N, dij.E, dij.neighbors, ('min', 'sum'), verbose=2)
    shortest_distances, local_paths = map(list, zip(*poolresults))
    dij.shortest_distances = dict(zip(dij.N, shortest_distances))
    MSD = dij.get_shortest_distances(format='dict', translate=True)
    #
    dict_edges_backbone = {}
    dict_edges_s_values = {}
    for (i, j), d in dict_edges.items():

        # Backbone = distance == distance-closure
        if d == MSD[i][j]:
            dict_edges_backbone[(i, j)] = True
        else:
            dict_edges_backbone[(i, j)] = False

        # S-Value = distance / distance-closure
        dict_edges_s_values[(i, j)] = d / MSD[i][j]

    return dict_edges_backbone, dict_edges_s_values
Beispiel #2
0
def test_dist2prox_prox2dist():
	""" Test Utils: Prox2Dist & Dist2Prox """
	assert np.isclose(dist2prox(prox2dist(P)) , P).all()
Beispiel #3
0
def test_dist2prox():
	""" Test Utils: Dist2Prox """
	assert np.isclose(prox2dist(P), D_true).all()
Beispiel #4
0
            icxl, icxh = module['xy-coords']['x-values']
            icyl, icyh = module['xy-coords']['y-values']

            dfPCA_tmp = dfPCA.loc[((dfPCA[icx] >= icxl) & (dfPCA[icx] <= icxh)
                                   & (dfPCA[icy] >= icyl) &
                                   (dfPCA[icy] <= icyh)), ['gene', icx, icy]]

            component_node_ids = dfPCA_tmp.index.to_list()

            #
            Gtc = nx.subgraph(Gt, component_node_ids)

            # Converting prox2dist
            nx.set_edge_attributes(Gtc,
                                   name='distance',
                                   values={(i, j): prox2dist(d['weight'])
                                           for i, j, d in Gt.edges(data=True)})
            #
            # Caculate Network Features
            #
            print('Calculating: degree centrality')
            dict_degree_centrality = nx.degree_centrality(Gt)
            nx.set_node_attributes(Gtc,
                                   name='degree_centrality',
                                   values=dict_degree_centrality)

            print("Calculating: eigevector centrality")
            dict_eigenvector_centrality = nx.eigenvector_centrality(
                Gtc, weight='weight')
            nx.set_node_attributes(Gtc,
                                   name='eigenvector_centrality',
from distanceclosure.dijkstra import Dijkstra
from distanceclosure.utils import prox2dist
import numpy as np
import networkx as nx
#
# Test
#
# Numpy
P = np.array([
		[1.,.9,.1,0.],
		[.9,1.,.8,0.],
		[.1,.8,1.,.6],
		[0.,0.,.6,1.],
		], dtype=float)
D = prox2dist(P)
#
# Edgelist
#
edgelist_luis = {
	('s','b'):.9,
	('s','c'):.1,
	('b','c'):.8,
	('c','d'):.6,
}

edgelist_james = {
	('s','a'):8,
	('s','c'):6,
	('s','d'):5,
	('a','d'):2,
	('a','e'):1,
Beispiel #6
0
	}
	"""
	edgelist = {
		('s','b'):.9,
		('s','c'):.1,
		('b','c'):.8,
		('c','d'):.6,
	}
	"""
	matrix = np.array([
			[1.,.9,.1,0.],
			[.9,1.,.8,0.],
			[.1,.8,1.,.6],
			[0.,0.,.6,1.],
			], dtype=float)
	matrix = prox2dist(matrix)

	sparse = csr_matrix(matrix)

	source = 2
	# NX
	#G = nx.from_edgelist(edgelist) 
	G = nx.from_numpy_matrix(matrix)
	#nx.set_edge_attributes(G, 'weight', edgelist)
	nx_lenghts = nx.single_source_dijkstra_path_length(G, source=source, weight='weight')
	nx_paths = nx.single_source_dijkstra_path(G, source=source, weight='weight')

	d = Dijkstra(verbose=True)
	#d.from_edgelist(edgelist, directed=False)
	#d.from_numpy_matrix(matrix, directed=False)
	d.from_sparse_matrix(sparse, directed=False)
Beispiel #7
0
    first_line = File.readlines()
    F = first_line[0].rstrip().split()
    for index in np.arange(len(rows)):
        Index_r = rows[index]
        Index_c = cols[index]
        if [F[Index_c], F[Index_r]] not in llista:
            llista.append([F[Index_r], F[Index_c]])
    File.close()
    return llista


# First, the DEanalysis.r script needs to be run to get the individual x individual correlation matrices.
# Convert to Distance
corr_matrix = 'Data/Correlation_matrix.txt'
corr_matrix_array = from_corr_matrix_to_array(corr_matrix)
D = prox2dist(corr_matrix_array)

# Calculate transitive closure using the metric and ultra-metric (also known maximum flow) measure
Cm = transitive_closure(D, kind='metric')
Cu = transitive_closure(D, kind='ultrametric')

# Retrieve the backbone edges
Bm = backbone(D, Cm)
Bu = backbone(D, Cu)

# Backbone edges on Bm and Bu can be accessed, where edges with a 1 are metric.
# We used the backbone edges based on the ultra-metric transitive closure.
rows, cols = np.where(Bu == 1)

# We get a two columns file where only the nodes that are connected through a backbone edge are showed.
t = ""