def centrality_opsahl(dg):
"""
TODO: reverse edges
"""
print "computing all pairs shortest path"
ds = all_pairs_shortest_path_length(dg)
print "done computing all pairs shortest path"
rank = {}
progress = 0
for x in dg.nodes():
r = 0.
if x not in ds:
continue
for v in ds[x]:
if ds[x][v] == 0:
continue
r += 1. / ds[x][v]
progress += 1
# for v in dg.nodes():
# if x == v:
# continue
# if x not in ds:
# continue
# if v not in ds[x]:
# continue
# r += 1. / ds[x][v]
rank[x] = r
if progress % 1000 == 0:
print "progress...", progress
return rank
def integration(self):
print('calculate integration at {}'.format(datetime.now()))
# Calculate shortest path between all nodes in the graph
path = dict(all_pairs_shortest_path_length(self.graph_pr))
print("finish to calculate shortest path between all pairs at {}".format(datetime.now()))
# store the integration index results for each edge
main_dict = {}
len_edge = len(self.graph_pr.edges)
# for each edge, the algorithm goes over all the nodes in graph and store the min shortest path between the node
# and its two nodes than add it to to int_index.
# at the end of each loop int_index divide by the number of lines (normalization)
# is literally the integration for the edge
for i, edge in enumerate(self.graph_pr.edges):
print("Progress {:2.1%}".format(i / len_edge))
int_index = 0
len_nodes = len(self.graph_pr.nodes)
for j, node in enumerate(self.graph_pr.nodes):
print(" Progress {:2.1%}".format(j / len_nodes))
weight_1 = path[edge[0]][node]
weight_2 = path[edge[1]][node]
miny = min(weight_1, weight_2)
int_index += miny
main_dict[edge] = int_index / len_edge
# add the results as a new properties to the edge's graph
nx.set_edge_attributes(self.graph_pr, main_dict, 'integ')
def __call__(self, data):
""" Compute a coloring such that no node sees twice the same color in its k-hop neighbourhood."""
k = self.k
g = torch_geometric.utils.to_networkx(data, to_undirected=True, remove_self_loops=True)
lengths = all_pairs_shortest_path_length(g, cutoff=2 * k)
lengths = [l for l in lengths]
# Graph where 2k hop neighbors are connected
k_hop_graph = nx.Graph()
for lengths_tuple in lengths:
origin = lengths_tuple[0]
edges = [(origin, dest) for dest in lengths_tuple[1].keys()]
k_hop_graph.add_edges_from(edges)
# Color the k-hop graph
best_n_colors = np.infty
best_color_dict = None
# for strategy in ['largest_first', 'random_sequential', 'saturation_largest_first']:
for strategy in ['largest_first']:
color_dict = greedy_color(k_hop_graph, strategy)
n_colors = np.max([color for color in color_dict.values()]) + 1
if n_colors < best_n_colors:
best_n_colors = n_colors
best_color_dict = color_dict
# Convert back to torch-geometric. The coloring is contained in data.x
data.coloring = torch.zeros((data.num_nodes, 1), dtype=torch.long)
for key, val in best_color_dict.items():
data.coloring[key] = val
print('Number of nodes: {} - Number of colors: {}'.format(data.num_nodes, data.coloring.max() + 1))
return data
def get_values(G, G_prime):
N = len(G.nodes())
print('Finding sortest paths...')
sys.stdout.flush()
SPG = dict(all_pairs_shortest_path_length(G))
SPG_prime = dict(all_pairs_shortest_path_length(G_prime))
print('Found sortest paths.')
sys.stdout.flush()
print('Generating LP...')
sys.stdout.flush()
diameter = 0
for i in range(0, N):
for j in range(i + 1, N):
if SPG[i][j] > diameter:
diameter = SPG[i][j]
(AGGP, bGGP) = lp_without_maxs_or_goal(N, SPG, SPG_prime, 1, size - 1)
print("Length is %s" % (len(bGGP)))
sys.stdout.flush()
# (AGGP, bGGP) = alternate_lp_without_maxs_or_goal(N, SPG, SPG_prime)
print('Generated LP.')
sys.stdout.flush()
c = goal_vector(N)
print('Solving LP...')
sys.stdout.flush()
G_with_G_prime = linprog(c,
A_ub=AGGP,
b_ub=bGGP,
method="interior-point",
options={
"disp": False,
"maxiter": N * N * N * N * 100
})
print('Solved LP...')
sys.stdout.flush()
return G_with_G_prime.x
def fraction_of_connected_node_pairs(G):
# computes how many pairs of nodes have a path between each other
if len(G) < 2:
return None
pairs_path_lens = all_pairs_shortest_path_length(G)
n_connected_pairs = 0
for i, i_p in pairs_path_lens:
for j, l in i_p.items():
if l > 0:
n_connected_pairs += 1
f_connected_pairs = n_connected_pairs / (len(G) * (len(G) - 1.0))
return f_connected_pairs
def centrality_opsahl(dg):
"""
TODO: reverse edges
"""
ds = all_pairs_shortest_path_length(dg)
rank = {}
for x in dg.nodes():
r = 0.
for v in dg.nodes():
if x == v:
continue
if x not in ds:
continue
if v not in ds[x]:
continue
r += 1. / ds[x][v]
rank[x] = r
return rank
def _calculate(self, include: set):
# Translating each label to a relevant index to save memory
labels_map = super(UndirectedNthNeighborNodeHistogramCalculator,
self)._calculate(include)
dists = unweighted.all_pairs_shortest_path_length(
self._gnx, cutoff=max(self._neighbor_order))
for i, (node, node_dists) in enumerate(dists):
for neighbor, neigh_dist in node_dists.items():
if (node == neighbor) or \
(neigh_dist not in self._neighbor_order) or \
(neighbor not in include) or \
("label" not in self._gnx.node[neighbor]):
continue
neighbor_color = self._gnx.node[neighbor]["label"]
if neighbor_color in labels_map:
neighbor_color = labels_map[neighbor_color]
self._features[node][neigh_dist][neighbor_color] += 1
def ls_rev(self):
if self.ls_rev_ is None:
self.ls_rev_ = dict(
all_pairs_shortest_path_length(self.g.reverse()))
return self.ls_rev_
def ls(self):
if self.ls_ is None:
self.ls_ = dict(all_pairs_shortest_path_length(self.g))
return self.ls_
