def edge(graph):
edge_attr = []
edge_attr = pd.DataFrame(list(
itertools.combinations(list(graph.nodes.keys()), r=2)),
columns=['source', 'target'])
edge_attr['shortest_path_length'] = edge_attr.apply(
lambda x: nx.shortest_path_length(graph, x[0], x[1])
if nx.has_path(graph, x[0], x[1]) else 0,
axis=1)
edge_attr['efficiency'] = edge_attr.apply(
lambda x: nx.efficiency(graph, x[0], x[1]), axis=1)
edge_attr['jaccard_coefficient'] = edge_attr.apply(
lambda x: link_pred_generator(nx.jaccard_coefficient)
(graph, x[0], x[1]),
axis=1)
edge_attr['resource_allocation_index'] = edge_attr.apply(
lambda x: link_pred_generator(nx.resource_allocation_index)
(graph, x[0], x[1]),
axis=1)
edge_attr['adamic_adar_index'] = edge_attr.apply(
lambda x: link_pred_generator(nx.adamic_adar_index)(graph, x[0], x[1]),
axis=1)
edge_attr['preferential_attachment'] = edge_attr.apply(
lambda x: link_pred_generator(nx.preferential_attachment)
(graph, x[0], x[1]),
axis=1)
return edge_attr
def test_efficiency(self):
assert_equal(nx.efficiency(self.G2, 0, 1), 1)
assert_equal(nx.efficiency(self.G2, 0, 2), 1 / 2)
def test_efficiency_disconnected_nodes(self):
"""
When nodes are disconnected, efficiency is 0
"""
assert_equal(nx.efficiency(self.G1, 1, 2), 0)
def test_efficiency(self):
assert_equal(nx.efficiency(self.G2, 0, 1), 1)
assert_equal(nx.efficiency(self.G2, 0, 2), 1 / 2)
def test_efficiency_disconnected_nodes(self):
"""
When nodes are disconnected, efficiency is 0
"""
assert_equal(nx.efficiency(self.G1, 1, 2), 0)
def test_efficiency():
G = nx.cycle_graph(4)
assert_equal(nx.efficiency(G, 0, 1), 1)
assert_equal(nx.efficiency(G, 0, 2), 1 / 2)
def test_efficiency():
G = nx.cycle_graph(4)
assert_equal(nx.efficiency(G, 0, 1), 1)
assert_equal(nx.efficiency(G, 0, 2), 1 / 2)
if key == 'geometry':
feature.SetGeometry(record[key])
else:
feature.SetField(key, record[key])
dst_layer.CreateFeature(feature)
# degree centrality
DC = nx.degree_centrality(G)
nx.set_node_attributes(G, DC, 'centr')
nodes = nx.nodes(G)
d_eff = {}
for node1 in nodes:
eff = []
for node2 in nodes:
if node1 != node2:
e = nx.efficiency(G, node1, node2)
eff.append(e)
ave = float(sum(eff) / len(eff))
d_eff[node1] = ave
nx.set_node_attributes(G, d_eff, 'Effic')
# nx.write_shp(G,r"D:\Projects\diploma\model\1993")
# local_edge_connectivity
le = {}
for n in nodes_g:
if n in node_dict:
l = []
for k in gen:
if k != n:
ec = nx.edge_connectivity(G, k, n)
l.append(ec)
def features_part2(info):
"""
third set of features.
"""
G = info['G']
n = info['num_nodes']
num_units = info['num_units']
edges = info['edges']
nedges = len(edges)
H = G.to_undirected()
res = dict()
cc = nx.closeness_centrality(G)
res['closeness_centrality'] = cc[n - 1]
res['closeness_centrality_mean'] = np.mean(list(cc.values()))
bc = nx.betweenness_centrality(G)
res['betweenness_centrality_mean'] = np.mean(list(bc.values()))
cfcc = nx.current_flow_closeness_centrality(H)
res['current_flow_closeness_centrality_mean'] = np.mean(list(
cfcc.values()))
cfbc = nx.current_flow_betweenness_centrality(H)
res['current_flow_betweenness_centrality_mean'] = np.mean(
list(cfbc.values()))
soc = nx.second_order_centrality(H)
res['second_order_centrality_mean'] = np.mean(list(soc.values())) / n
cbc = nx.communicability_betweenness_centrality(H)
res['communicability_betweenness_centrality_mean'] = np.mean(
list(cbc.values()))
comm = nx.communicability(H)
res['communicability'] = np.log(comm[0][n - 1])
res['communicability_start_mean'] = np.log(np.mean(list(comm[0].values())))
res['communicability_end_mean'] = np.log(
np.mean(list(comm[n - 1].values())))
res['radius'] = nx.radius(H)
res['diameter'] = nx.diameter(H)
res['local_efficiency'] = nx.local_efficiency(H)
res['global_efficiency'] = nx.global_efficiency(H)
res['efficiency'] = nx.efficiency(H, 0, n - 1)
pgr = nx.pagerank_numpy(G)
res['page_rank'] = pgr[n - 1]
res['page_rank_mean'] = np.mean(list(pgr.values()))
cnstr = nx.constraint(G)
res['constraint_mean'] = np.mean(list(cnstr.values())[:-1])
effsize = nx.effective_size(G)
res['effective_size_mean'] = np.mean(list(effsize.values())[:-1])
cv = np.array(list(nx.closeness_vitality(H).values()))
cv[cv < 0] = 0
res['closeness_vitality_mean'] = np.mean(cv) / n
res['wiener_index'] = nx.wiener_index(H) / (n * (n - 1) / 2)
A = nx.to_numpy_array(G)
expA = expm(A)
res['expA'] = np.log(expA[0, n - 1])
res['expA_mean'] = np.log(np.mean(expA[np.triu_indices(n)]))
return res
def test_efficiency(self):
assert nx.efficiency(self.G2, 0, 1) == 1
assert nx.efficiency(self.G2, 0, 2) == 1 / 2
def efficiency(uG, ni, nj, rand_node):
a = nx.efficiency(uG, ni, nj)
b = nx.efficiency(uG, ni, rand_node)
return a, b
