def fail():
fig = plt.figure()
ax = plt.axes()
def update(i):
_G = frames[i]['f']
ax.clear()
pos = nx.spring_layout(_G)
# Draw nodes & edges.
nx.draw_networkx_nodes(_G, pos, node_size=700, ax=ax)
nx.draw_networkx_labels(_G, pos, ax=ax)
nx.draw_networkx_edges(_G, pos, width=6, ax=ax)
ax.set_title(frames[i]['t'])
print(_io.getvalue())
print(Gt.sum())
print(Gt)
print(list(nx.find_cliques(G)))
graphity.utils.print_as_graph(G)
print(nx.node_clique_number(G, [i for i in range(len(G))]))
ani = matplotlib.animation.FuncAnimation(fig,
update,
interval=1000,
frames=len(frames),
repeat=False)
my_writer = matplotlib.animation.PillowWriter(fps=1,
codec='libx264',
bitrate=2)
ani.save(filename='gif_test.gif', writer=my_writer)
assert 0
def find_cliques(master_edges, roots):
cliq = []
for e in range(0, len(master_edges)):
G = nx.Graph(master_edges[e])
print(nx.node_clique_number(G, roots[e]))
return (cliq)
def test_stats(g,
mc_size=500,
verbose=True,
maxclique=True,
return_results=False):
nodesamp = np.random.choice(list(g.nodes()), mc_size, replace=False)
num_nodes = g.number_of_nodes()
verbose and print("- num nodes: {:d}".format(num_nodes))
num_edges = g.number_of_edges()
verbose and print("- num edges: {:d}".format(num_edges))
edge_node_ratio = num_edges / num_nodes
verbose and print("- edge node ratio: {:2.2f}".format(edge_node_ratio))
num_triang = sum(nx.triangles(g, i) for i in nodesamp) / 3
triang_node_ratio = num_triang / mc_size
verbose and print("- triang node ratio: {:2.2f}".format(triang_node_ratio))
density = 2 * num_edges / num_nodes / (num_nodes - 1)
verbose and print("- density: {:2.6f}".format(density))
deg = np.mean([nx.degree(g, i) for i in g.nodes()])
verbose and print("- mean degree: {:2.2f}".format(deg))
#clust_coeff = np.mean([nx.clustering(g, i) for i in nodesamp])
clust_coeff = approximation.clustering_coefficient.average_clustering(
g, trials=mc_size)
verbose and print("- clustering coefficient: {:2.2f}".format(clust_coeff))
if maxclique:
max_clique_node = np.mean(
[nx.node_clique_number(g, i) for i in nodesamp])
verbose and print("- mean maximal clique containing node: {:2.2f}".
format(max_clique_node))
else:
max_clique_node = 0
conn_comp = sorted(list(nx.connected_components(g)),
key=lambda x: len(x),
reverse=True)
conn_comp_sizes = [len(xi) for xi in conn_comp]
verbose and print("- connected component sizes (top 5):",
conn_comp_sizes[:5])
short_paths = 0
for i in range(0): # not used currently...
pair = np.random.choice(list(conn_comp[0]), 2, replace=False)
short_paths += nx.dijkstra_path_length(g, *pair) / mc_size
verbose and print(
"- mean distance between nodes (largest conn. comp.): {:2.2f}".format(
short_paths))
if return_results:
return num_nodes, num_edges, edge_node_ratio, density, deg, max_clique_node, clust_coeff, conn_comp_sizes[
0], short_paths, triang_node_ratio
else:
return
def test_node_clique_number(self):
G = self.G
assert_equal(nx.node_clique_number(G, 1), 4)
assert_equal(list(nx.node_clique_number(G, [1]).values()), [4])
assert_equal(list(nx.node_clique_number(G, [1, 2]).values()), [4, 4])
assert_equal(nx.node_clique_number(G, [1, 2]), {1: 4, 2: 4})
assert_equal(nx.node_clique_number(G, 1), 4)
assert_equal(nx.node_clique_number(G), {
1: 4,
2: 4,
3: 4,
4: 3,
5: 3,
6: 4,
7: 3,
8: 2,
9: 2,
10: 2,
11: 2
})
assert_equal(nx.node_clique_number(G, cliques=self.cl), {
1: 4,
2: 4,
3: 4,
4: 3,
5: 3,
6: 4,
7: 3,
8: 2,
9: 2,
10: 2,
11: 2
})
def test_node_clique_number(self):
G = self.G
assert nx.node_clique_number(G, 1) == 4
assert list(nx.node_clique_number(G, [1]).values()) == [4]
assert list(nx.node_clique_number(G, [1, 2]).values()) == [4, 4]
assert nx.node_clique_number(G, [1, 2]) == {1: 4, 2: 4}
assert nx.node_clique_number(G, 1) == 4
assert (nx.node_clique_number(G) == {
1: 4,
2: 4,
3: 4,
4: 3,
5: 3,
6: 4,
7: 3,
8: 2,
9: 2,
10: 2,
11: 2
})
assert (nx.node_clique_number(G, cliques=self.cl) == {
1: 4,
2: 4,
3: 4,
4: 3,
5: 3,
6: 4,
7: 3,
8: 2,
9: 2,
10: 2,
11: 2
})
def degree_clique_density_orig(g, grid_deg, grid_clique):
degs = np.array([nx.degree(g, i) for i in g.nodes()], dtype=float)
clique = np.array([nx.node_clique_number(g, i) for i in g.nodes()],
dtype=float)
dens_deg = fit_kde(degs, grid_deg)
dens_clique = fit_count(clique, grid_clique)
return dens_deg, dens_clique
def calculate_undir_centralities(self, G, U, suffix):
''' Calculate centralities in undirected graph and add them as node attributes '''
nx.set_node_attributes(G, nx.degree_centrality(U),
'degree_%s' % suffix)
nx.set_node_attributes(G, nx.node_clique_number(U),
'clique_number_%s' % suffix)
nx.set_node_attributes(G, nx.number_of_cliques(U),
'num_of_cliques_%s' % suffix)
return G
def test_node_clique_number(self):
G=self.G
assert_equal(nx.node_clique_number(G,1),4)
assert_equal(list(nx.node_clique_number(G,[1]).values()),[4])
assert_equal(list(nx.node_clique_number(G,[1,2]).values()),[4, 4])
assert_equal(nx.node_clique_number(G,[1,2]),{1: 4, 2: 4})
assert_equal(nx.node_clique_number(G,1),4)
assert_equal(nx.node_clique_number(G),
{1: 4, 2: 4, 3: 4, 4: 3, 5: 3, 6: 4,
7: 3, 8: 2, 9: 2, 10: 2, 11: 2})
assert_equal(nx.node_clique_number(G,cliques=self.cl),
{1: 4, 2: 4, 3: 4, 4: 3, 5: 3, 6: 4,
7: 3, 8: 2, 9: 2, 10: 2, 11: 2})
def degree_clique_density(prior_samples, grid_deg, grid_clique):
dens_deg = np.zeros(len(grid_deg))
dens_clique = np.zeros(len(grid_clique))
n = len(prior_samples)
for i, (Z, net, links) in enumerate(prior_samples):
g = nx.Graph()
g.add_edges_from(links)
degs = np.array([nx.degree(g, i) for i in g.nodes()], dtype=float)
clique = np.array([nx.node_clique_number(g, i) for i in g.nodes()],
dtype=float)
dens_deg += fit_kde(degs, grid_deg) / n
dens_clique += fit_count(clique, grid_clique) / n
return dens_deg, dens_clique
def week4():
path = "D:\Dropbox\PhD\My Work\Algorithms\@Machine Learning\Lectures\Social Network Analysis\Week 4_Community Structure\wikipedia.gml"
wiki = nx.read_gml(path)
wiki = wiki.to_undirected()
# cliques
cid, cls = max(nx.node_clique_number(wiki).iteritems(), key=operator.itemgetter(1))
print 'clique', cid, ' size:', cls
# k-cores
kcs = nx.k_core(wiki)
print 'k-core size:', len(kcs.node)
# community
cs = list(nx.k_clique_communities(wiki, 2))
ratio = (len(cs[0]) + 0.0) / len(wiki.node)
print 'community ratio:', ratio
def make_small_domains(self, domains, max_eval):
small_domains = {}
#disconnectedComp = list(nx.components.connected.connected_component_subgraphs(self.triangulated_graph))
disconnectedComp = [ self.triangulated_graph.subgraph(c) for c in nx.connected_components(self.triangulated_graph) ]
nDiscComp = len(disconnectedComp)
max_eval += self.overflow(domains, max_eval)
for subgraph in disconnectedComp:
N_subgraph = max_eval * subgraph.number_of_nodes() / self.triangulated_graph.number_of_nodes() # number of evaluations for this component
n_clique_var = 0
for clique in nx.find_cliques(subgraph):
n_clique_var += len(clique)
for var in subgraph.nodes():
clique_size = nx.node_clique_number(subgraph, var)
N_clique = clique_size * N_subgraph / n_clique_var # number of evaluation for this clique
N_var = max(int(round(N_clique**(1.0/clique_size))), 2)
small_domains[var] = self.choose_from(domains[var], N_var)
return small_domains
def compute_node_measures(ntwk, calculate_cliques=False):
"""
These return node-based measures
"""
iflogger.info('Computing node measures:')
measures = {}
iflogger.info('...Computing degree...')
measures['degree'] = np.array(list(ntwk.degree().values()))
iflogger.info('...Computing load centrality...')
measures['load_centrality'] = np.array(
list(nx.load_centrality(ntwk).values()))
iflogger.info('...Computing betweenness centrality...')
measures['betweenness_centrality'] = np.array(
list(nx.betweenness_centrality(ntwk).values()))
iflogger.info('...Computing degree centrality...')
measures['degree_centrality'] = np.array(
list(nx.degree_centrality(ntwk).values()))
iflogger.info('...Computing closeness centrality...')
measures['closeness_centrality'] = np.array(
list(nx.closeness_centrality(ntwk).values()))
# iflogger.info('...Computing eigenvector centrality...')
# measures['eigenvector_centrality'] = np.array(nx.eigenvector_centrality(ntwk, max_iter=100000).values())
iflogger.info('...Computing triangles...')
measures['triangles'] = np.array(list(nx.triangles(ntwk).values()))
iflogger.info('...Computing clustering...')
measures['clustering'] = np.array(list(nx.clustering(ntwk).values()))
iflogger.info('...Computing k-core number')
measures['core_number'] = np.array(list(nx.core_number(ntwk).values()))
iflogger.info('...Identifying network isolates...')
isolate_list = nx.isolates(ntwk)
binarized = np.zeros((ntwk.number_of_nodes(), 1))
for value in isolate_list:
value = value - 1 # Zero indexing
binarized[value] = 1
measures['isolates'] = binarized
if calculate_cliques:
iflogger.info('...Calculating node clique number')
measures['node_clique_number'] = np.array(
list(nx.node_clique_number(ntwk).values()))
iflogger.info('...Computing number of cliques for each node...')
measures['number_of_cliques'] = np.array(
list(nx.number_of_cliques(ntwk).values()))
return measures
def avg_pay_off(self,t=None,PD=False, G=None):
if PD:
F = transform_di_simple(G)
high_receivers_low_share = np.array([0])
else:
F = transform_di_weight_simple(self.agents,0.95)
high_receivers_low_share = np.array([self.agents.node[i]['rewards'][-1] for i in transform_high_receivers(self.agents,0.95)])
max_clique_membership = [nx.node_clique_number(F,i)>=3 for i in F.nodes()]
#print (max_clique_membership)
in_clique = np.array([self.agents.node[i]['rewards'][-1] for i in [value for value in range(len(max_clique_membership)) if max_clique_membership[value]==True]])
not_in_clique = np.array([self.agents.node[i]['rewards'][-1] for i in [value for value in range(len(max_clique_membership)) if max_clique_membership[value]==False]])
prop_clique = np.size(in_clique)/self.n_agents
#print (in_clique,not_in_clique,np.array([self.agents.node[i]['rewards'][-1] for i in range(len(self.agents))]))
mean_clique_members = np.mean(in_clique)
mean_non_clique_members = np.mean(not_in_clique)
mean_h_receivers_low_share = np.mean(high_receivers_low_share)
mean_all = np.mean(np.array([self.agents.node[i]['rewards'][-1] for i in range(len(self.agents))]))
oracle_performance = self.bandits.field[self.oracle].draw_sample()
return mean_all, mean_clique_members, mean_non_clique_members, prop_clique, mean_h_receivers_low_share
def compute_node_measures(ntwk, calculate_cliques=False):
"""
These return node-based measures
"""
iflogger.info('Computing node measures:')
measures = {}
iflogger.info('...Computing degree...')
measures['degree'] = np.array(list(ntwk.degree().values()))
iflogger.info('...Computing load centrality...')
measures['load_centrality'] = np.array(
list(nx.load_centrality(ntwk).values()))
iflogger.info('...Computing betweenness centrality...')
measures['betweenness_centrality'] = np.array(
list(nx.betweenness_centrality(ntwk).values()))
iflogger.info('...Computing degree centrality...')
measures['degree_centrality'] = np.array(
list(nx.degree_centrality(ntwk).values()))
iflogger.info('...Computing closeness centrality...')
measures['closeness_centrality'] = np.array(
list(nx.closeness_centrality(ntwk).values()))
# iflogger.info('...Computing eigenvector centrality...')
# measures['eigenvector_centrality'] = np.array(nx.eigenvector_centrality(ntwk, max_iter=100000).values())
iflogger.info('...Computing triangles...')
measures['triangles'] = np.array(list(nx.triangles(ntwk).values()))
iflogger.info('...Computing clustering...')
measures['clustering'] = np.array(list(nx.clustering(ntwk).values()))
iflogger.info('...Computing k-core number')
measures['core_number'] = np.array(list(nx.core_number(ntwk).values()))
iflogger.info('...Identifying network isolates...')
isolate_list = nx.isolates(ntwk)
binarized = np.zeros((ntwk.number_of_nodes(), 1))
for value in isolate_list:
value = value - 1 # Zero indexing
binarized[value] = 1
measures['isolates'] = binarized
if calculate_cliques:
iflogger.info('...Calculating node clique number')
measures['node_clique_number'] = np.array(
list(nx.node_clique_number(ntwk).values()))
iflogger.info('...Computing number of cliques for each node...')
measures['number_of_cliques'] = np.array(
list(nx.number_of_cliques(ntwk).values()))
return measures
def degree_clique_density_bnpgraph(dbname, grid_deg, grid_clique):
dens_deg = np.zeros(len(grid_deg))
dens_clique = np.zeros(len(grid_clique))
n = 25
for k in range(n):
links = np.genfromtxt('bnpgraph_runs/' + dbname + '_' + str(k + 1) +
'.tsv',
delimiter='\t',
dtype=int)
g = nx.Graph()
g.add_edges_from(links - 1)
degs = np.array([nx.degree(g, i) for i in g.nodes()], dtype=float)
clique = np.array([nx.node_clique_number(g, i) for i in g.nodes()],
dtype=float)
dens_deg += fit_kde(degs, grid_deg) / n
dens_clique += fit_count(clique, grid_clique) / n
return dens_deg, dens_clique
def is_pure(tensor, k):
"""
Warning!: This requires solving an NP hard problem.
This may take exponential time.
Please pass in small graphs for your own sake.
Determines if the input graph is pure.
For a graph to be pure, the maximal clique number at every site must be the same size.
:param tensor: A torch.Tensor containing all {0, 1}.
This tensor's maximal clique size and purity status is not known.
"""
if type(tensor) != nx.Graph: G = nx.from_numpy_matrix(tensor.cpu().numpy())
else: G = tensor
sizes = nx.node_clique_number(G, list(G.nodes()))
# Must iterate over values, since sizes is a dict.
cond = all(x == k for x in sizes.values())
for p in nx.find_cliques(G):
cond = cond and len(p) == k
#if not cond: print([k for k in sizes if sizes[k] == max_v])
return cond
def degree_clique_density_krongen(dbname, grid_deg, grid_clique):
dens_deg = np.zeros(len(grid_deg))
dens_clique = np.zeros(len(grid_clique))
n = 25
for k in range(n):
links = np.genfromtxt('krongen_runs/' + dbname +
'_{:02d}.tsv'.format(k + 1),
delimiter='\t',
dtype=int)
g = nx.Graph()
for i, j in links:
if i < j:
g.add_edge(i, j)
degs = np.array([nx.degree(g, i) for i in g.nodes()], dtype=float)
clique = np.array([nx.node_clique_number(g, i) for i in g.nodes()],
dtype=float)
dens_deg += fit_kde(degs, grid_deg) / n
dens_clique += fit_count(clique, grid_clique) / n
return dens_deg, dens_clique
#!/usr/bin/python3
from networkx import Graph, node_clique_number
edges = []
with open('./decoded.txt', 'r') as input_file:
edges = list(
filter(lambda line: line.startswith("e"), input_file.readlines()))
G = Graph()
for edge in edges:
_, a, b = edge.strip().split(" ")
G.add_edge(int(a), int(b))
print(f"Done! Built graph {G.number_of_nodes()}")
print(f"Edge list: {len(G.edges)}")
nice_kids = [
104, 118, 55, 51, 123, 110, 111, 116, 95, 84, 72, 69, 126, 70, 76, 65, 71,
33, 61, 40, 124, 115, 48, 60, 62, 83, 79, 42, 82, 121, 125, 45, 98, 114,
101, 97, 100
]
clique_containing_nice_kids = node_clique_number(G, nice_kids)
flag_parts = map(chr, clique_containing_nice_kids.values())
flag = "".join(flag_parts)
print(flag) # HV20{Max1mal_Cl1qu3_Enum3r@t10n_Fun!}
def MaxCliqueSize(self):
return nx.node_clique_number(self.G).values().pop()
g = ABPUtils.ReadGraph(args.graph)
# Now make a version of the graph that does not have any repulsion edges
repl = []
ga = g.copy()
for e in ga.edges():
if ga[e[0]][e[1]]['cost'] < 0:
repl.append(e)
ga.remove_edges_from(repl)
if args.cliques:
for n in ga.nodes():
print "clique: " + str(n) + "\t" + str(len(ga[n])) + "\t" + str(
nx.node_clique_number(ga, n))
if args.degreeSummary:
for s in g:
nGood = 0
nBad = 0
nNeutral = 0
p = nx.shortest_path(g, s)
pa = nx.shortet_path(ga, s)
for d in g[s]:
if g[s][d]['cost'] > 0:
nGood += 1
if g[s][d]['cost'] == 0:
nNeutral += 1
if g[s][d]['cost'] < 0:
nBad += 1
print "Compute clique number - size of the largest clique" print "-------------------------------------" graphCliqueNumber = nx.graph_clique_number(G, cliques) print graphCliqueNumber print "-------------------------------------" print "Compute number of maximal ciiques" print "-------------------------------------" graphNumberOfCliques = nx.graph_number_of_cliques(G, cliques) print graphNumberOfCliques print "-------------------------------------" print "Compute size of largest maximal clique containing a given node" print "-------------------------------------" maximalCliqueSizePerNode = nx.node_clique_number(G) print maximalCliqueSizePerNode print "-------------------------------------" print "Compute number of maximal cliques for each node" print "-------------------------------------" noOfMaximalCliquesPerNode = nx.number_of_cliques(G) print noOfMaximalCliquesPerNode print "-------------------------------------" print "Compute list of cliques containing a given node" print "-------------------------------------" lcliques = nx.cliques_containing_node(G) print lcliques print "-------------------------------------"
def generate_graph_features(path):
"""
Generate graph features for question pairs data.
Features will be written in a csv file in path folder.
Args:
path: folder containing train.csv and test.csv and to write csv features file.
Return:
"""
# Load training and test set
train = pd.read_csv(
os.path.join(path, 'train.csv'),
sep=',',
names=["id", "qid1", "qid2", "question1", "question2", "is_duplicate"])
test = pd.read_csv(os.path.join(path, 'test.csv'),
sep=',',
names=["id", "qid1", "qid2", "question1", "question2"])
# Drop useless columns
train = train.drop(['id', 'question1', 'question2', 'is_duplicate'],
axis=1)
test = test.drop(['id', 'question1', 'question2'], axis=1)
train_test = pd.concat([train, test], ignore_index=True)
# Initialize graph
G = nx.Graph()
# Create edges
edge_list = []
for index, row in train_test.iterrows():
edge_list.append(
[train_test['qid1'][index], train_test['qid2'][index]])
G.add_edges_from(edge_list)
print('Number of nodes:', G.number_of_nodes())
print('Number of edges:', G.number_of_edges())
# Computing train features
print('Computing train features')
for index, row in tqdm(train.iterrows()):
# Generate neighbors of each questions
neigh_1 = G.neighbors(train['qid1'][index])
neigh_2 = G.neighbors(train['qid2'][index])
# Number of neigbors
train.loc[index, 'q1_neigh'] = len(neigh_1)
train.loc[index, 'q2_neigh'] = len(neigh_2)
# Count the common and the distinct neighbors
train.loc[index, 'common_neigh'] = len(
list(
nx.common_neighbors(G, train['qid1'][index],
train['qid2'][index])))
train.loc[index, 'distinct_neigh'] = len(neigh_1) + len(neigh_2) - len(
list(
nx.common_neighbors(G, train['qid1'][index],
train['qid2'][index])))
# Compute the clique size
train.loc[index, 'clique_size'] = nx.node_clique_number(
G, train['qid1'][index])
# Generate shortest path
# Cut the edge to compute features
G.remove_edge(train['qid1'][index], train['qid2'][index])
# Compute shortest path
try:
train.loc[index, 'shortest_path'] = nx.shortest_path_length(
G, train['qid1'][index], train['qid2'][index])
except NetworkXNoPath:
train.loc[index, 'shortest_path'] = 10
# Reset the edge
G.add_edge(train['qid1'][index], train['qid2'][index])
# Drop the useless columns
train = train.drop(['qid1', 'qid2'], axis=1)
print('Writing train features...')
train.to_csv(os.path.join(path, 'train_graph_feat.csv'))
print('Computing test features')
for index, row in tqdm(test.iterrows()):
# Generate neighbors of each questions
neigh_1 = G.neighbors(test['qid1'][index])
neigh_2 = G.neighbors(test['qid2'][index])
# Number of neigbors
test.loc[index, 'q1_neigh'] = len(neigh_1)
test.loc[index, 'q2_neigh'] = len(neigh_2)
# Count the common and the distinct neighbors
test.loc[index, 'common_neigh'] = len(
list(
nx.common_neighbors(G, test['qid1'][index],
test['qid2'][index])))
test.loc[index, 'distinct_neigh'] = len(neigh_1) + len(neigh_2) - len(
list(
nx.common_neighbors(G, test['qid1'][index],
test['qid2'][index])))
# Compute the clique size
test.loc[index, 'clique_size'] = nx.node_clique_number(
G, test['qid1'][index])
# Generate shortest path
# Cut the edge to compute features
G.remove_edge(test['qid1'][index], test['qid2'][index])
# Compute shortest path
try:
test.loc[index, 'shortest_path'] = nx.shortest_path_length(
G, test['qid1'][index], test['qid2'][index])
except NetworkXNoPath:
test.loc[index, 'shortest_path'] = 10
# Reset the edge
G.add_edge(test['qid1'][index], test['qid2'][index])
# Drop the useless columns
test = test.drop(['qid1', 'qid2'], axis=1)
print('Writing test features...')
test.to_csv(os.path.join(path, 'test_graph_feat.csv'))
print('CSV written ! see: ', path, " | suffix: ", "_graph_feat.csv")
g = G.copy()
core = nx.core_number(g)
clique = {}
degree = {}
Cc = {}
h1_index = {}
list = []
file_ = xx + "+data.txt"
ff = open(file_, "a")
ff.write("Nd\t\t\tDg\t\t\tCq\t\t\tCc\t\t\tH1\t\t\tSn")
for i in g.nodes():
clique[i] = nx.node_clique_number(g, nodes=i)
degree[i] = g.degree(i)
print("\n")
print(degree[i])
if degree[i] == 1:
Cc[i] = 1
else:
Cc[i] = round(nx.clustering(g, i), 2)
for each in g.neighbors(i):
list.append(g.degree(each))
print(list)
h1_index[i] = h_operator(list)
del list[:]
ff.write("\n")
ff.write(str(i))
ff.write("\t\t\t")
def get_graph(Mat_D, Threshold, percentageConnections=False, complet=False):
import scipy.io as sio
import numpy as np
import networkx as nx
import pandas as pd
import os
Data = sio.loadmat(Mat_D)
matX = Data['Correlation'] #[:tamn,:tamn]
labels = Data['labels']
print(np.shape(matX))
print(np.shape(labels))
print(np.min(matX), np.max(matX))
if percentageConnections:
if percentageConnections > 0 and percentageConnections < 1:
for i in range(-100, 100):
per = np.sum(matX > i / 100.) / np.size(matX)
if per <= Threshold:
Threshold = i / 100.
break
print(Threshold)
else:
print('The coefficient is outside rank')
#Lista de conexion del grafo
row, col = np.shape(matX)
e = []
for i in range(1, row):
for j in range(i):
if complet:
e.append((labels[i], labels[j], matX[i, j]))
else:
if matX[i, j] > Threshold:
e.append((labels[i], labels[j], matX[i, j]))
print(np.shape(e)[0], int(((row - 1) * row) / 2))
#Generar grafo
G = nx.Graph()
G.add_weighted_edges_from(e)
labelNew = list(G.nodes)
#Metricas por grafo (ponderados)
Dpc = nx.degree_pearson_correlation_coefficient(G, weight='weight')
cluster = nx.average_clustering(G, weight='weight')
#No ponderados
estra = nx.estrada_index(G)
tnsity = nx.transitivity(G)
conNo = nx.average_node_connectivity(G)
ac = nx.degree_assortativity_coefficient(G)
#Metricas por nodo
tam = 15
BoolCenV = False
BoolLoad = False
alpha = 0.1
beta = 1.0
katxCN = nx.katz_centrality_numpy(G,
alpha=alpha,
beta=beta,
weight='weight')
bcen = nx.betweenness_centrality(G, weight='weight')
av_nd = nx.average_neighbor_degree(G, weight='weight')
ctr = nx.clustering(G, weight='weight')
ranPaN = nx.pagerank_numpy(G, weight='weight')
Gol_N = nx.hits_numpy(G)
Dgc = nx.degree_centrality(G)
cl_ce = nx.closeness_centrality(G)
cluster_Sq = nx.square_clustering(G)
centr = nx.core_number(G)
cami = nx.node_clique_number(G)
camiN = nx.number_of_cliques(G)
trian = nx.triangles(G)
colorG = nx.greedy_color(G)
try:
cenVNum = nx.eigenvector_centrality_numpy(G, weight='weight')
tam = tam + 1
BoolCenV = True
except TypeError:
print(
"La red es muy pequeña y no se puede calcular este parametro gil")
except:
print('NetworkXPointlessConcept: graph null')
if Threshold > 0:
carga_cen = nx.load_centrality(G, weight='weight') #Pesos positivos
BoolLoad = True
tam = tam + 1
#katxC=nx.katz_centrality(G, alpha=alpha, beta=beta, weight='weight')
#cenV=nx.eigenvector_centrality(G,weight='weight')
#cenV=nx.eigenvector_centrality(G,weight='weight')
#Golp=nx.hits(G)
#Gol_si=nx.hits_scipy(G)
#ranPa=nx.pagerank(G, weight='weight')
#ranPaS=nx.pagerank_scipy(G, weight='weight')
matrix_datos = np.zeros((tam, np.shape(labelNew)[0]))
tam = 15
print(np.shape(matrix_datos))
lim = np.shape(labelNew)[0]
for i in range(lim):
roi = labelNew[i]
#print(roi)
matrix_datos[0, i] = katxCN[roi]
matrix_datos[1, i] = bcen[roi]
matrix_datos[2, i] = av_nd[roi]
matrix_datos[3, i] = ctr[roi]
matrix_datos[4, i] = ranPaN[roi]
matrix_datos[5, i] = Gol_N[0][roi]
matrix_datos[6, i] = Gol_N[1][roi]
matrix_datos[7, i] = Dgc[roi]
matrix_datos[8, i] = cl_ce[roi]
matrix_datos[9, i] = cluster_Sq[roi]
matrix_datos[10, i] = centr[roi]
matrix_datos[11, i] = cami[roi]
matrix_datos[12, i] = camiN[roi]
matrix_datos[13, i] = trian[roi]
matrix_datos[14, i] = colorG[roi]
if BoolCenV:
matrix_datos[15, i] = cenVNum[roi]
tam = tam + 1
if BoolLoad:
matrix_datos[16, i] = carga_cen[roi]
tam = tam + 1
#matrix_datos[0,i]=katxC[roi]
#matrix_datos[2,i]=cenV[roi]
#matrix_datos[7,i]=Golp[0][roi]
#matrix_datos[9,i]=Gol_si[0][roi]
#matrix_datos[10,i]=Golp[1][roi]
#matrix_datos[12,i]=Gol_si[1][roi]
#matrix_datos[22,i]=ranPa[roi]
#matrix_datos[24,i]=ranPaS[roi]
FuncName = [
'degree_pearson_correlation_coefficient', 'average_clustering',
'estrada_index', 'transitivity', 'average_node_connectivity',
'degree_assortativity_coefficient', 'katz_centrality_numpy',
'betweenness_centrality', 'average_neighbor_degree', 'clustering',
'pagerank_numpy', 'hits_numpy0', 'hits_numpy1', 'degree_centrality',
'closeness_centrality', 'square_clustering', 'core_number',
'node_clique_number', 'number_of_cliques', 'triangles', 'greedy_color',
'eigenvector_centrality_numpy', 'load_centrality'
]
frame = pd.DataFrame(matrix_datos)
frame.columns = labelNew
frame.index = FuncName[6:tam]
Resul = os.getcwd()
out_data = Resul + '/graph_metrics.csv'
out_mat = Resul + '/graph_metrics_global.mat'
frame.to_csv(out_data)
sio.savemat(
out_mat, {
FuncName[0]: Dpc,
FuncName[1]: cluster,
FuncName[2]: estra,
FuncName[3]: tnsity,
FuncName[4]: conNo,
FuncName[5]: ac
})
return out_data, out_mat
# print sorted(nx.connected_components(G), key = len, reverse=True)
print str(" ")
print 'Το λεξικό των κλικών που περιέχουν κάθε κόμβο είναι:'
# print 'The dictionary of the lists of cliques containing each node:'
print nx.cliques_containing_node(G)
print str(" ")
print 'Το λεξικό του πλήθους κλικών που περιέχουν κάθε κόμβο είναι:'
# print 'The dictionary of the numbers of maximal cliques for each node:'
print nx.number_of_cliques(G)
print str(" ")
print 'Το λεξικό του μεγέθους των μεγαλύτερων κλικών που περιέχουν κάθε κόμβο είναι:'
# print 'The dictionary of the sizes of the largest maximal cliques containing each given node:'
print nx.node_clique_number(G)
print str(" ")
maxclique = [
clq for clq in nx.find_cliques(G) if len(clq) == nx.graph_clique_number(G)
]
nodes = [n for clq in maxclique for n in clq]
H = G.subgraph(nodes)
# print H.edges()
#### ΣΧΕΔΙΑΣΜΟΣ ΚΛΙΛΩΝ ΜΕΣΑ ΣΕ ΠΕΡΙΒΑΛΛΟΜΕΝΕΣ ΧΡΩΜΑΤΙΣΜΕΝΕΣ ΠΕΡΙΟΧΕΣ
import igraph as ig
file_name = str(G.name) + str(lvl2) + '.graphml'
file_dir = 'temp'
try:
def calc_centralities(G,org_name,string_version):
print("Calculating centralities")
centrality_measures = {}
string_location=f.string_version_data(string_version)[0]
print(string_location)
# if 1==0:
if os.path.isfile('centrality_data/%s/%s.cent'%(string_location,org_name)):
print("Using cached centrality data")
file=open('centrality_data/%s/%s.cent'%(string_location,org_name))
lines=file.readlines()
centrality_list=lines.pop(0).strip().split(' ')
centrality_list.pop(0)
for i,centrality in enumerate(centrality_list):
centrality_measures[centrality]={}
for line in lines:
value_list=line.split(' ')
for i,centrality in enumerate(centrality_list):
# print("%d. %s" % (i+1,centrality))
centrality_measures[centrality][value_list[0]]=float(value_list[i+1])
else:
print("1. Degree centrality")
centrality_measures['Degree_Centrality']=nx.degree_centrality(G)
print("2. Closeness centrality")
centrality_measures['Closeness_Centrality']=Counter(nx.algorithms.centrality.closeness_centrality(G))
print("3. Betweenness centrality")
centrality_measures['Betweenness_Centrality']=Counter(nx.algorithms.centrality.betweenness_centrality(G))
print("4. Clustering coefficient")
centrality_measures['Clustering_Co-efficient']=Counter(nx.clustering(G))
print("5. Eigenvector centrality")
centrality_measures['Eigenvector_Centrality']= nx.eigenvector_centrality(G)
print("6. Subgraph centrality")
centrality_measures["Subgraph_Centrality"]=nx.subgraph_centrality(G)
print("7. Information centrality")
centrality_measures["Information_Centrality"]=nx.current_flow_closeness_centrality(f.trim_graph(G))
print("8. Clique Number")
cliq={}
for i in G.nodes():
cliq[i]=nx.node_clique_number(G,i)
centrality_measures["Clique_Number"]=cliq
print("9. Edge clustering coefficient")
edge_clus_coeff={}
for n in G.nodes:
edge_clus_coeff[n]=0
for e in G.edges(n):
num=len(list(nx.common_neighbors(G,e[0],e[1])))
den=(min(G.degree(e[0]),G.degree(e[1]))-1)
if den==0:
den=1
edge_clus_coeff[n]+=num/den
centrality_measures['Edge_Clustering_Coefficient']=edge_clus_coeff
print("10. Page Rank")
centrality_measures['Page_Rank']=nx.pagerank(G)
print("11. Random Walk Betweenness Centrality")
centrality_measures["Random_Walk_Betweenness_Centrality"]=nx.current_flow_betweenness_centrality(f.trim_graph(G))
print("12. Load Centrality")
centrality_measures["Load_Centrality"]=nx.load_centrality(G)
print("13. Communicability Betweenness")
centrality_measures["Communicability_Betweenness"]=nx.communicability_betweenness_centrality(f.trim_graph(G))
print("14. Harmonic Centrality")
centrality_measures["Harmonic_Centrality"]=nx.harmonic_centrality(G)
print("15. Reaching Centrality")
reach_cent={}
for node in G.nodes:
reach_cent[node] = nx.local_reaching_centrality(G,node)
centrality_measures["Reaching_Centrality"]=reach_cent
print("16. Katz Centrality(not calculated)")
# centrality_measures["Katz_Centrality"]=nx.katz_centrality(G)
datafile=open("refex_props/%s.refex" % (org_name))
sample_line=datafile.readline()
s= sample_line.strip().split(' ')
for x in range(1,len(s)):
centrality_measures["refex#%d" % (x)]={}
for line in datafile:
props=line.strip().split(" ")
props=[i.strip('\t') for i in props]
for x in range(1,len(s)):
centrality_measures["refex#%d" % (x)][props[0]]=float(props[x])
datafile=open("refex_rider_props/%s.riderproperties" % (org_name))
sample_line=datafile.readline()
s= sample_line.strip().split(' ')
s.pop(1)
print(len(s))
for x in range(1,len(s)):
centrality_measures["refex_rider#%d" % (x)]={}
for line in datafile:
props=line.strip().split(" ")
props.pop(1)
for x in range(1,len(props)):
centrality_measures["refex_rider#%d" % (x)][props[0]]=float(props[x])
with open('centrality_data/%s/%s.cent'%(string_location,org_name),'w') as file:
file.write(str(org_name)+' ')
centrality_list=list(centrality_measures)
for x in centrality_list:
file.write(str(x)+' ')
for node in G.nodes:
file.write('\n'+node+' ')
for x in centrality_list:
if node not in centrality_measures[x]:
file.write('-1 ')
else:
file.write(str(centrality_measures[x][node])+' ')
return centrality_measures
for articles in db.view('_all_docs'): ##search quoter in autors
j=articles['id']
if db[j]["Author"] == quoter: ##quoter is an author in database
for quot in db[j]["Quoters"]: #search author in qouters of quoter
if quot == Aut:
H.add_node(quot)
H.add_node(Aut)
H.add_edge(Aut, quoter)
nx.draw(H,pos=nx.spring_layout(H))
NumOfCliqes=nx.graph_clique_number(H)
print ("Clique number of the graph : ")
print (NumOfCliqes)
#
MaxCliques = nx.find_cliques(H)
print ("All maximal cliques: ")
print(list(MaxCliques))
##
node_clique_number=nx.node_clique_number(H)
print ("Size of the largest maximal clique containing each given node")
print (node_clique_number)
number_of_cliques=nx.number_of_cliques(H)
print ("Number of maximal cliques for each node.")
print (number_of_cliques)
# -*- coding: utf-8 -*-
"""
AFRS - Trabalho 4
Author: Gonçalo Peres
Date: 2019/02/02
"""
import networkx as nx
g = nx.read_gml('dolphins.gml')
clique = nx.node_clique_number(g)
print(clique)
def MaxCliqueSize(self):
return nx.node_clique_number(self.G).values().pop()
# print sorted(nx.connected_components(G), key = len, reverse=True)
print str(" ")
print "Το λεξικό των κλικών που περιέχουν κάθε κόμβο είναι:"
# print 'The dictionary of the lists of cliques containing each node:'
print nx.cliques_containing_node(G)
print str(" ")
print "Το λεξικό του πλήθους κλικών που περιέχουν κάθε κόμβο είναι:"
# print 'The dictionary of the numbers of maximal cliques for each node:'
print nx.number_of_cliques(G)
print str(" ")
print "Το λεξικό του μεγέθους των μεγαλύτερων κλικών που περιέχουν κάθε κόμβο είναι:"
# print 'The dictionary of the sizes of the largest maximal cliques containing each given node:'
print nx.node_clique_number(G)
print str(" ")
maxclique = [clq for clq in nx.find_cliques(G) if len(clq) == nx.graph_clique_number(G)]
nodes = [n for clq in maxclique for n in clq]
H = G.subgraph(nodes)
# print H.edges()
#### ΣΧΕΔΙΑΣΜΟΣ ΚΛΙΛΩΝ ΜΕΣΑ ΣΕ ΠΕΡΙΒΑΛΛΟΜΕΝΕΣ ΧΡΩΜΑΤΙΣΜΕΝΕΣ ΠΕΡΙΟΧΕΣ
import igraph as ig
file_name = str(G.name) + str(lvl2) + ".graphml"
file_dir = "temp"
try:
def cliqueNumber(self, cdata):
tdata = []
cliques = nx.node_clique_number(self.graph, [d[0] for d in cdata])
for d in cdata:
tdata.append((d[1], cliques[d[0]]))
return tdata
line += str(i[l])+'\t'
line += '\n'
f.write(line)
return even
path_name = 'pti01100'
attribute = 'origin'
G = extract.G
set_attribute(G,path_name+'/'+path_name+'cor.nodes',attribute)
between = nx.betweenness_centrality(G)
degree = nx.degree(G)
degree_c = nx.degree_centrality(G)
closeness = nx.closeness_centrality(G)
clique = nx.node_clique_number(G)
nx.set_node_attributes(G,'betweenness',between)
nx.set_node_attributes(G,'degree',degree)
nx.set_node_attributes(G,'degree.centrality',degree_c)
nx.set_node_attributes(G,'closeness',closeness)
nx.set_node_attributes(G,'clique',clique) #size of the largest clique containing node
#clustering coefficient
for g in nx.connected_component_subgraphs(G):
graph = nx.Graph(g) #this attribute does not exist for MultiGraph
cluster = nx.clustering(graph)
nx.set_node_attributes(G,'clustering.coefficient',cluster)
write_nodes_attributes(G,path_name+'/'+path_name+'.csv')
ev= shuffle_even(G,"origin",["BAC","PROK","EUK","ARC"],10000,path_name)
G = nx.Graph()
print 'loading edges'
for i in temp1:
G.add_edge(i[0], i[1])
print 'loading nodes'
for i in temp2:
G.add_node(i[0])
print 'calc core number'
cn = nx.core_number(G)
print 'calc clique number'
kn = nx.node_clique_number(G)
print 'calc number of cliques'
kn2 = nx.number_of_cliques(G)
print 'calculating node measures'
for u, e in G.nodes_iter(data=True):
dr = str(nx.degree(G, u))
cl = str(nx.clustering(G, u))
#cc = str(nx.betweenness_centrality(G)[u])
ct = cn[u]
knu = kn[u]
kn2u = kn2[u]
#ks = str(nx.k_shell(G)[u])
f3.write(u + " " + dr + " " + cl + " " + str(ct) + " " + str(knu) + " " +
str(kn2u) + "\n")
f3.close()
