def classify(request, pk):
#gets object based on id given
graph_file = get_object_or_404(Document, pk=pk)
#reads file into networkx graph based on extension
if graph_file.extension() == ".gml":
G = nx.read_gml(graph_file.uploadfile)
else:
G = nx.read_gexf(graph_file.uploadfile)
#closes file so we can delete it
graph_file.uploadfile.close()
#loads the algorithm and tests the algorithm against the graph
g_json = json_graph.node_link_data(G)
#save graph into json file
with open(os.path.join(settings.MEDIA_ROOT, 'graph.json'), 'w') as graph:
json.dump(g_json, graph)
with open(os.path.join(settings.MEDIA_ROOT, 'rf_classifier.pkl'), 'rb') as malgo:
algo_loaded = pickle.load(malgo, encoding="latin1")
dataset = np.array([G.number_of_nodes(), G.number_of_edges(), nx.density(G), nx.degree_assortativity_coefficient(G), nx.average_clustering(G), nx.graph_clique_number(G)])
print (dataset)
#creates X to test against
X = dataset
prediction = algo_loaded.predict(X)
graph_type = check_prediction(prediction)
graph = GraphPasser(G.number_of_nodes(), G.number_of_edges(), nx.density(G), nx.degree_assortativity_coefficient(G), nx.average_clustering(G), nx.graph_clique_number(G))
#gives certain variables to the view
return render(
request,
'classification/classify.html',
{'graph': graph, 'prediction': graph_type}
)
def knn_pack(graph, *kwargs):
t = dict()
for k in kwargs:
t.__setitem__(k, kwargs[k])
t.__setitem__('asr', nx.degree_assortativity_coefficient(graph))
t.__setitem__('weighted_asr', nx.degree_assortativity_coefficient(graph, weight = 'weight'))
if graph.is_directed():
t.__setitem__('knn', nx.average_degree_connectivity(graph, source = 'out', target = 'in'))
if len(nx.get_edge_attributes(graph, 'weight')):
t.__setitem__('weighted_knn', nx.average_degree_connectivity(graph, source = 'out', target = 'in', weight = 'weight'))
else:
t.__setitem__('knn', nx.average_degree_connectivity(graph))
if len(nx.get_edge_attributes(graph, 'weight')):
t.__setitem__('weighted_knn', nx.average_degree_connectivity(graph, weight = 'weight'))
return(t)
def gpn_stats(genes, gpn, version):
LOGGER.info("Computing GPN statistics")
nodes = sorted(gpn.nodes_iter())
components = sorted(nx.connected_components(gpn), key=len, reverse=True)
ass = nx.degree_assortativity_coefficient(gpn)
deg = [gpn.degree(node) for node in nodes]
stats = pd.DataFrame(data={
"version": version,
"release": pd.to_datetime(RELEASE[version]),
"num_genes": len(genes),
"num_nodes": len(nodes),
"num_links": gpn.size(),
"density": nx.density(gpn),
"num_components": len(components),
"largest_component": len(components[0]),
"assortativity": ass,
"avg_deg": mean(deg),
"hub_deg": max(deg)
}, index=[1])
stats["release"] = pd.to_datetime(stats["release"])
dists = pd.DataFrame(data={
"version": version,
"release": [pd.to_datetime(RELEASE[version])] * len(nodes),
"node": [node.unique_id for node in nodes],
"degree": deg,
})
return (stats, dists)
def draw_graph(nodes, edges, graphs_dir, default_lang='all'):
lang_graph = nx.MultiDiGraph()
lang_graph.add_nodes_from(nodes)
for edge in edges:
if edges[edge] == 0:
lang_graph.add_edge(edge[0], edge[1])
else:
lang_graph.add_edge(edge[0], edge[1], weight=float(edges[edge]), label=str(edges[edge]))
# print graph info in stdout
# degree centrality
print('-----------------\n\n')
print(default_lang)
print(nx.info(lang_graph))
try:
# When ties are associated to some positive aspects such as friendship or collaboration,
# indegree is often interpreted as a form of popularity, and outdegree as gregariousness.
DC = nx.degree_centrality(lang_graph)
max_dc = max(DC.values())
max_dc_list = [item for item in DC.items() if item[1] == max_dc]
except ZeroDivisionError:
max_dc_list = []
# https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8
print('maxdc', str(max_dc_list), sep=': ')
# assortativity coef
AC = nx.degree_assortativity_coefficient(lang_graph)
print('AC', str(AC), sep=': ')
# connectivity
print("Слабо-связный граф: ", nx.is_weakly_connected(lang_graph))
print("количество слабосвязанных компонент: ", nx.number_weakly_connected_components(lang_graph))
print("Сильно-связный граф: ", nx.is_strongly_connected(lang_graph))
print("количество сильносвязанных компонент: ", nx.number_strongly_connected_components(lang_graph))
print("рекурсивные? компоненты: ", nx.number_attracting_components(lang_graph))
print("число вершинной связности: ", nx.node_connectivity(lang_graph))
print("число рёберной связности: ", nx.edge_connectivity(lang_graph))
# other info
print("average degree connectivity: ", nx.average_degree_connectivity(lang_graph))
print("average neighbor degree: ", sorted(nx.average_neighbor_degree(lang_graph).items(),
key=itemgetter(1), reverse=True))
# best for small graphs, and our graphs are pretty small
print("pagerank: ", sorted(nx.pagerank_numpy(lang_graph).items(), key=itemgetter(1), reverse=True))
plt.figure(figsize=(16.0, 9.0), dpi=80)
plt.axis('off')
pos = graphviz_layout(lang_graph)
nx.draw_networkx_edges(lang_graph, pos, alpha=0.5, arrows=True)
nx.draw_networkx(lang_graph, pos, node_size=1000, font_size=12, with_labels=True, node_color='green')
nx.draw_networkx_edge_labels(lang_graph, pos, edges)
# saving file to draw it with dot-graphviz
# changing overall graph view, default is top-bottom
lang_graph.graph['graph'] = {'rankdir': 'LR'}
# marking with blue nodes with maximum degree centrality
for max_dc_node in max_dc_list:
lang_graph.node[max_dc_node[0]]['fontcolor'] = 'blue'
write_dot(lang_graph, os.path.join(graphs_dir, default_lang + '_links.dot'))
# plt.show()
plt.savefig(os.path.join(graphs_dir, 'python_' + default_lang + '_graph.png'), dpi=100)
plt.close()
def compute_singlevalued_measures(ntwk, weighted=True, calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info("Computing single valued measures:")
measures = {}
iflogger.info("...Computing degree assortativity (pearson number) ...")
try:
measures["degree_pearsonr"] = nx.degree_pearsonr(ntwk)
except AttributeError: # For NetworkX 1.6
measures["degree_pearsonr"] = nx.degree_pearson_correlation_coefficient(ntwk)
iflogger.info("...Computing degree assortativity...")
try:
measures["degree_assortativity"] = nx.degree_assortativity(ntwk)
except AttributeError:
measures["degree_assortativity"] = nx.degree_assortativity_coefficient(ntwk)
iflogger.info("...Computing transitivity...")
measures["transitivity"] = nx.transitivity(ntwk)
iflogger.info("...Computing number of connected_components...")
measures["number_connected_components"] = nx.number_connected_components(ntwk)
iflogger.info("...Computing average clustering...")
measures["average_clustering"] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info("...Calculating average shortest path length...")
measures["average_shortest_path_length"] = nx.average_shortest_path_length(ntwk, weighted)
if calculate_cliques:
iflogger.info("...Computing graph clique number...")
measures["graph_clique_number"] = nx.graph_clique_number(ntwk) # out of memory error
return measures
def Attributes_of_Graph(G):
print "*Statistic attributes of graphs:"
print "N", nx.number_of_nodes(G)
print "M", nx.number_of_edges(G)
print "C", nx.average_clustering(G)
#print "<d>", nx.average_shortest_path_length(G)
print "r", nx.degree_assortativity_coefficient(G)
degree_list = list(G.degree_iter())
max_degree = 0
min_degree = 0
avg_degree_1 = 0.0
avg_degree_2 = 0.0
for node in degree_list:
avg_degree_1 = avg_degree_1 + node[1]
avg_degree_2 = avg_degree_2 + node[1]*node[1]
if node[1] > max_degree:
max_degree = node[1]
if node[1] < min_degree:
min_degree = node[1]
#end for
avg_degree = avg_degree_1/len(degree_list)
avg_degree_square = (avg_degree_2/len(degree_list)) / (avg_degree*avg_degree)
print "<k>", avg_degree
print "k_max", max_degree
print "H", avg_degree_square
print "DH", float(max_degree-min_degree)/G.number_of_nodes()
def degree_assortativity(G):
#this wrapper helps avoid error due to change in interface name
if hasattr(nx, 'degree_assortativity_coefficient'):
return nx.degree_assortativity_coefficient(G)
elif hasattr(nx, 'degree_assortativity'):
return nx.degree_assortativity(G)
else:
raise ValueError, 'Cannot compute degree assortativity: method not available'
def SR_nx_assortativity():
#os.chdir("SR_graphs")
os.chdir(IN_DIR_SR)
SR=nx.read_edgelist(f_in_graph_SR, create_using=nx.Graph()) #, data=(('weight',int),))
print(len(SR.nodes(data=True)))
print "Degree assortativity of UNWEIGHTED is %f " % nx.degree_assortativity_coefficient(SR)
#print "Sentiment (by value) numeric assortativity is %f " % nx.numeric_assortativity_coefficient(MENT, 'sentiment_val')
SR=nx.read_edgelist(f_in_graph_SR, create_using=nx.Graph(), data=(('weight',int),))
print(len(SR.nodes(data=True)))
print "Degree assortativity of WEIGHTED is %f " % nx.degree_assortativity_coefficient(SR, weight='weight')
cnt = 0
d=defaultdict(int)
d_val = defaultdict(int)
d1 = defaultdict(int)
with open(f_in_user_sentiment) as f:
for line in f:
(uid, label, val) = line.split()
uid = unicode(uid)
d1[uid]= int(float(val)*10000)
if uid in SR.nodes():
d[uid]= int(float(val)*10000)
d_val[uid] = int(label)
else:
cnt += 1
print "Number of nodes for which we have sentminet but are not in the mention graph is ", cnt
cnt = 0
for node in SR.nodes():
if not node in d1:
cnt += 1
SR.remove_node(node)
print "Number of nodes that do not have sentiment value, so we remove them from the mention graph", cnt
nx.set_node_attributes(SR, 'sentiment' , d)
nx.set_node_attributes(SR, 'sentiment_val' , d_val)
print "Final number of nodes in the graph ", (len(SR.nodes(data=True)))
print "Sentiment (by label) nominal numeric assortativity is %f " % nx.numeric_assortativity_coefficient(SR, 'sentiment')
print "Sentiment (by value) numeric assortativity is %f " % nx.numeric_assortativity_coefficient(SR, 'sentiment_val')
def trn_stats(genes, trn, t_factors, version):
LOGGER.info("Computing TRN statistics")
nodes = sorted(trn.nodes_iter())
node2id = {n: i for (i, n) in enumerate(nodes)}
id2node = {i: n for (i, n) in enumerate(nodes)}
(grn, node2id) = to_simple(trn.to_grn(), return_map=True)
nodes = sorted(grn.nodes_iter())
regulating = {node for (node, deg) in grn.out_degree_iter() if deg > 0}
regulated = set(nodes) - regulating
components = sorted(nx.weakly_connected_components(grn), key=len,
reverse=True)
data = dict()
for (a, b) in itertools.product(("in", "out"), repeat=2):
data["{a}_{b}_ass".format(a=a, b=b)] = nx.degree_assortativity_coefficient(grn, x=a, y=b)
census = triadic_census(grn)
forward = census["030T"]
feedback = census["030C"]
num_cycles = sum(1 for cyc in nx.simple_cycles(grn) if len(cyc) > 2)
in_deg = [grn.in_degree(node) for node in regulated]
out_deg = [grn.out_degree(node) for node in regulating]
data["version"] = version,
data["release"] = pd.to_datetime(RELEASE[version]),
data["num_genes"] = len(genes),
data["num_tf"] = len(t_factors),
data["num_nodes"] = len(nodes),
data["num_regulating"] = len(regulating),
data["num_regulated"] = len(regulated),
data["num_links"] = grn.size(),
data["density"] = nx.density(grn),
data["num_components"] = len(components),
data["largest_component"] = len(components[0]),
data["feed_forward"] = forward,
data["feedback"] = feedback,
data["fis_out"] = trn.out_degree(TranscriptionFactor[FIS_ID, version]),
data["hns_out"] = trn.out_degree(TranscriptionFactor[HNS_ID, version]),
data["cycles"] = num_cycles,
data["regulated_in_deg"] = mean(in_deg),
data["regulating_out_deg"] = mean(out_deg),
data["hub_out_deg"] = max(out_deg)
stats = pd.DataFrame(data, index=[1])
in_deg = [grn.in_degree(node) for node in nodes]
out_deg = [grn.out_degree(node) for node in nodes]
bc = nx.betweenness_centrality(grn)
bc = [bc[node] for node in nodes]
dists = pd.DataFrame({
"version": version,
"release": [pd.to_datetime(RELEASE[version])] * len(nodes),
"node": [id2node[node].unique_id for node in nodes],
"regulated_in_degree": in_deg,
"regulating_out_degree": out_deg,
"betweenness": bc
})
return (stats, dists)
def info_network(G):
from networkx.algorithms import bipartite
from decimal import Decimal
print G.number_of_nodes()
print G.number_of_edges()
print "average_neighbor_degree"
dict = nx.average_neighbor_degree(G)
list1 = dict.keys()
list2 = dict.values()
print list1
print list2
print "degree_assortativity_coefficient"
print nx.degree_assortativity_coefficient(G)
print "degree_pearson_correlation_coefficient"
print nx.degree_pearson_correlation_coefficient(G)
# print nx.k_nearest_neighbors(G)
print "STOP HERE"
print "bipartite.closeness_centrality(G,G.node)"
dict2 = bipartite.closeness_centrality(G, G.node)
list3 = dict2.values()
print list3
print "nx.degree_centrality(G)"
dict3 = nx.degree_centrality(G)
list4 = dict3.values()
print list4
print "nx.betweenness_centrality(G)"
dict4 = nx.betweenness_centrality(G)
list5 = dict4.values()
print list5
print "hits_numpy"
dict5 = nx.hits_numpy(G)
print dict5
def main():
domain_name = 'baidu.com'
domain_pkts = get_data(domain_name)
node_cname, node_ip, visit_total, edges, node_main = get_ip_cname(domain_pkts[0]['details'])
for i in domain_pkts[0]['details']:
for v in i['answers']:
edges.append((v['domain_name'],v['dm_data']))
DG = nx.DiGraph()
DG.add_edges_from(edges)
# 分析域名直接解析为IP的node
for node in DG:
if node in node_main and DG.successors(node) in node_ip:
print node
# 分析cname关联的IP数量分布
for node in DG:
if node in node_cname and DG.successors(node) not in node_cname: # 查找与ip直接连接的cname
print "node",DG.out_degree(node),DG.in_degree(node),DG.degree(node)
# 与cname关联的域名个数
# for node in DG:
# if node in node_cname and DG.predecessors(node) not in node_cname:
# print len(DG.predecessors(node))
for node in DG:
if node in node_main:
if len(DG.successors(node)) ==3:
print node
print DG.successors(node)
# print sorted(nx.degree(DG).values())
print nx.degree_assortativity_coefficient(DG)
average_degree = sum(nx.degree(DG).values())/(len(node_cname)+len(node_ip)+len(node_main))
print average_degree
print len(node_cname)+len(node_ip)+len(node_main)
print len(edges)
print nx.degree_histogram(DG)
def compute_singlevalued_measures(ntwk, weighted=True,
calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info('Computing single valued measures:')
measures = {}
iflogger.info('...Computing degree assortativity (pearson number) ...')
try:
measures['degree_pearsonr'] = nx.degree_pearsonr(ntwk)
except AttributeError: # For NetworkX 1.6
measures[
'degree_pearsonr'] = nx.degree_pearson_correlation_coefficient(
ntwk)
iflogger.info('...Computing degree assortativity...')
try:
measures['degree_assortativity'] = nx.degree_assortativity(ntwk)
except AttributeError:
measures['degree_assortativity'] = nx.degree_assortativity_coefficient(
ntwk)
iflogger.info('...Computing transitivity...')
measures['transitivity'] = nx.transitivity(ntwk)
iflogger.info('...Computing number of connected_components...')
measures['number_connected_components'] = nx.number_connected_components(
ntwk)
iflogger.info('...Computing graph density...')
measures['graph_density'] = nx.density(ntwk)
iflogger.info('...Recording number of edges...')
measures['number_of_edges'] = nx.number_of_edges(ntwk)
iflogger.info('...Recording number of nodes...')
measures['number_of_nodes'] = nx.number_of_nodes(ntwk)
iflogger.info('...Computing average clustering...')
measures['average_clustering'] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info('...Calculating average shortest path length...')
measures[
'average_shortest_path_length'] = nx.average_shortest_path_length(
ntwk, weighted)
else:
iflogger.info('...Calculating average shortest path length...')
measures[
'average_shortest_path_length'] = nx.average_shortest_path_length(
nx.connected_component_subgraphs(ntwk)[0], weighted)
if calculate_cliques:
iflogger.info('...Computing graph clique number...')
measures['graph_clique_number'] = nx.graph_clique_number(
ntwk) # out of memory error
return measures
def run(self):
ip_addresses = [
'192.168.1.%s' % x for x in range(1, self._number_clients + 1)
]
ports = [x for x in range(1, 2)]
clients = []
progress = 0
for ip_addr in ip_addresses:
progress += 1
print_progress(progress,
self._number_clients,
suffix="Running simulation")
for port in ports:
client = Client(
ip_addr,
port,
clients[0] if len(clients) > 0 else None,
max_chache_size=self._number_connections_per_client)
clients.append(client)
connection = Connection(client, clients[0])
connection.initiate()
bootstrapper_connections = clients[0].get_connections()
for conn in bootstrapper_connections:
connection = Connection(client, conn.second_client)
connection.initiate()
graph = networkx.nx.Graph()
for client in clients:
logging.info(client.get_ident())
logging.info(client.get_connection_idents())
for node in client.get_connections():
graph.add_edge(node.first_client.get_ident(),
node.second_client.get_ident())
networkx.draw(graph, with_labels=False)
plt.savefig("path_graph.pdf")
print("Network is connected: %s" % networkx.is_connected(graph))
print("Average shortest path length: %s" %
networkx.average_shortest_path_length(graph))
print("Average bipartite clustering coefficient %s" %
networkx.average_clustering(graph))
print("Bipartite clustering coefficient %s" %
networkx.clustering(graph))
print("degree_assortativity_coefficient %s" %
networkx.degree_assortativity_coefficient(graph))
def network_info(networks,
names=None,
plot=False,
bin_size=1,
colors=None,
reverse_plot=False):
import networkx
networks = [networks] if not isinstance(networks, list) else networks
names = [names] if not isinstance(names, list) else names
colors = [colors
] if (colors is not None and not isinstance(colors, list)) else (
colors if colors is not None else
pyplot.rcParams['axes.prop_cycle'].by_key()['color'])
for i, (network, name) in enumerate(zip(networks, names)):
degree = [d[1] for d in network.degree()]
if (name):
print(name + ":")
print(
"Degree: mean = %.2f, std = %.2f, 95%% CI = (%.2f, %.2f)\n coeff var = %.2f"
% (numpy.mean(degree), numpy.std(degree),
numpy.percentile(degree, 2.5), numpy.percentile(
degree, 97.5), numpy.std(degree) / numpy.mean(degree)))
r = networkx.degree_assortativity_coefficient(network)
print("Assortativity: %.2f" % (r))
c = networkx.average_clustering(network)
print("Clustering coeff: %.2f" % (c))
print()
if (plot):
pyplot.hist(degree,
bins=numpy.arange(0,
int(max(degree) + 1),
step=bin_size),
label=(name + " degree" if name else False),
color=colors[i],
edgecolor='white',
alpha=0.6,
zorder=(-1 * i if reverse_plot else i))
if (plot):
pyplot.ylabel('num nodes')
pyplot.legend(loc='upper right')
pyplot.show()
def batched_graphs_generator(basedir, clusterings, name, mus=None):
# num_graphs = 5 if 'polblogs' in name else 10
num_graphs = 10
use_pickle = True
save_snapshots = False
attr_name = 'value'
mus = [5]
alpha = None
input_graphs = read_batched_graphs(basedir=basedir, name=name)
extract_types = ['mu_random']
args = []
for i, input_graph in enumerate(input_graphs):
mix_dict = get_mixing_dict(input_graph, attr_name=attr_name)
inp_deg_ast = nx.degree_assortativity_coefficient(input_graph)
inp_attr_ast = nx.attribute_assortativity_coefficient(
input_graph, attr_name)
for grammar_filename in glob(
f'{basedir}/output/grammars/{name}/*_{i}.pkl'):
grammar = load_pickle(grammar_filename)
if grammar.mu not in mus or grammar.clustering not in clusterings or grammar.extract_type not in extract_types:
continue
extract_type = grammar.extract_type.replace('_', '-')
if isinstance(grammar, AttributedVRG):
for gen_type, fancy in zip(('AVRG-regular', 'AVRG-fancy'),
(False, True)):
graphs_filename = f'{basedir}/output/graphs/{name}/{gen_type}_{extract_type}_{grammar.clustering}_{grammar.mu}_{num_graphs}_{i}.pkl'
args.append((name, grammar, num_graphs, extract_type,
gen_type, basedir, graphs_filename, mix_dict,
attr_name, fancy, inp_deg_ast, inp_attr_ast,
use_pickle, save_snapshots, alpha))
for alpha, gen_type in zip(
(0, 0.5, 1),
('AVRG-greedy-attr', 'AVRG-greedy-50', 'AVRG-greedy-deg')):
graphs_filename = f'{basedir}/output/graphs/{name}/{gen_type}_{extract_type}_{grammar.clustering}_{grammar.mu}_{num_graphs}_{i}.pkl'
args.append((name, grammar, num_graphs, extract_type,
gen_type, basedir, graphs_filename, mix_dict,
attr_name, fancy, inp_deg_ast, inp_attr_ast,
use_pickle, save_snapshots, alpha))
# random.shuffle(args)
parallel_async(func=generate_graphs, args=args, num_workers=8)
return
def getStatsA(graph):
getMean = lambda container: reduce(lambda i,j: i+j, container)/float(len(container))
getVariance = lambda container,mean: getMean(map(lambda x: pow(float(x)-mean, 2), container))
degreeNodes = graph.degree(graph.nodes()).values()
numOfNodes = len(graph.nodes())
numOfEdges = len(graph.edges())
graphDensity = 2*numOfEdges/float(numOfNodes*(numOfNodes-1))
averageDegree = getMean(degreeNodes)
varianceDegree = getVariance(degreeNodes, averageDegree)
print("Exercise 1:")
print("Number of nodes: ", str(numOfNodes))
print("Number of edges: ", str(numOfEdges))
print("Link density: ", str(graphDensity))
print("Average degree: ", str(averageDegree))
print("Variance degree: ", str(varianceDegree))
print("Exercise 2:")
assortativity = nx.degree_assortativity_coefficient(graph)
print("Exercise 3:")
print("Assortativity: ", str(assortativity), "Positive value indications that there is a correlation between nodes of similar degree," \
+ " while negative values indicate that there is a correlation between nodes of different degree.")
clusteringCoefficient = nx.average_clustering(graph)
print("Exercise 4:")
print("Average clustering coefficient: ", str(clusteringCoefficient))
averageHopCount = nx.average_shortest_path_length(graph)
diameter = nx.diameter(graph)
print("Exercise 5:")
print("Average hop count: ", str(averageHopCount))
print("Diameter:", str(diameter))
print("Exercise 6:")
adjacencySpectrum = sorted(nx.adjacency_spectrum(graph))
print("Exercise 7:")
print("Spectral radius (largest eigenvalue of the adjacency matrix):", str(adjacencySpectrum[-1]))
laplacianSpectrum = sorted(nx.laplacian_spectrum(graph))
print("Exercise 8:")
print("Algebraic connectivity (second largest eigenvalue of the laplacian matrix):", str(laplacianSpectrum[-2]))
def main():
"""
Entry point.
"""
if len(sys.argv) == 1:
sys.exit("Usage: python evolving_network.py <params file>")
# Load the parameters.
params = json.load((open(sys.argv[1], "r")))
seedNetwork = params["seedNetwork"]
# Setup the seed network.
if seedNetwork["name"] == "read_graphml":
G = networkx.convert_node_labels_to_integers(\
networkx.read_graphml(seedNetwork["args"]["path"]))
else:
G = getattr(networkx, seedNetwork["name"])(**seedNetwork["args"])
# Evolve G.
R = robustness(G, params["attackStrategy"], params["sequentialMode"])
countDown = params["stagnantEpochs"]
while countDown > 0:
if params["verbose"]:
v = numpy.var(G.degree().values()) # degree variance
l = networkx.average_shortest_path_length(G) # avg. path length
C = networkx.average_clustering(G) # clustering
r = networkx.degree_assortativity_coefficient(G) # assortativity
print("%.4f %.4f %.4f %.4f %.4f" %(R, v, l, C, r))
mutants = genMutants(G, params)
prevR = R
for mutant in mutants:
mutantR = robustness(mutant, params["attackStrategy"],
params["sequentialMode"])
if params["maximizeRobustness"] and mutantR > R or \
not params["maximizeRobustness"] and mutantR < R:
R = mutantR
G = mutant
if params["maximizeRobustness"] and R > prevR or \
not params["maximizeRobustness"] and R < prevR:
countDown = params["stagnantEpochs"]
else:
countDown -= 1
# Save G.
networkx.write_graphml(G, params["outFile"])
def main():
"""
Entry point.
"""
if len(sys.argv) == 1:
sys.exit("Usage: python evolving_network.py <params file>")
# Load the parameters.
params = json.load((open(sys.argv[1], "r")))
seedNetwork = params["seedNetwork"]
# Setup the seed network.
if seedNetwork["name"] == "read_graphml":
G = networkx.convert_node_labels_to_integers(\
networkx.read_graphml(seedNetwork["args"]["path"]))
else:
G = getattr(networkx, seedNetwork["name"])(**seedNetwork["args"])
# Evolve G.
R = robustness(G, params["attackStrategy"], params["sequentialMode"])
countDown = params["stagnantEpochs"]
while countDown > 0:
if params["verbose"]:
v = numpy.var(G.degree().values()) # degree variance
l = networkx.average_shortest_path_length(G) # avg. path length
C = networkx.average_clustering(G) # clustering
r = networkx.degree_assortativity_coefficient(G) # assortativity
print("%.4f %.4f %.4f %.4f %.4f" % (R, v, l, C, r))
mutants = genMutants(G, params)
prevR = R
for mutant in mutants:
mutantR = robustness(mutant, params["attackStrategy"],
params["sequentialMode"])
if params["maximizeRobustness"] and mutantR > R or \
not params["maximizeRobustness"] and mutantR < R:
R = mutantR
G = mutant
if params["maximizeRobustness"] and R > prevR or \
not params["maximizeRobustness"] and R < prevR:
countDown = params["stagnantEpochs"]
else:
countDown -= 1
# Save G.
networkx.write_graphml(G, params["outFile"])
def _refineSph(self):
G = self._makeG()
A = nx.betweenness_centrality(G) # betweeness centrality
B = nx.clustering(G)
C = nx.degree(G)
for v in G:
self.Spheroid['cells'][v]['degree'] = C[v]
self.Spheroid['cells'][v]['clustering'] = B[v]
self.Spheroid['cells'][v]['centrality'] = A[v]
self.Spheroid['N'] = len(self.Spheroid['cells'])
self.Spheroid['assortativity'] = nx.degree_assortativity_coefficient(G)
self.Spheroid['average degree'] = np.asarray([float(C[v])
for v in G]).mean()
def generate_graph_statistics(G):
n = nx.number_of_nodes(G)
m = nx.number_of_edges(G)
degree_sequence = np.array([d for n, d in nx.degree(G)])
k_mean = degree_sequence.mean()
k_max = degree_sequence.max()
std = np.std(degree_sequence)
cc = nx.average_clustering(G)
c = nx.number_connected_components(G)
assortativity = nx.degree_assortativity_coefficient(G)
largest_cc = max(nx.connected_components(G), key=len)
G_giant = G.subgraph(largest_cc)
n_giant = nx.number_of_nodes(G_giant)
m_giant = nx.number_of_edges(G_giant)
return [n, m, k_mean, k_max, std, cc, c, assortativity, n_giant, m_giant]
def social_properties(G):
G.graph['clustering'] = nx.average_clustering(G)
G.graph['transitivity'] = nx.transitivity(G)
try:
G.graph['assortativity'] = nx.degree_assortativity_coefficient(G)
except ValueError:
G.graph['assortativity'] = 0
if nx.is_connected(G):
G.graph['char_path_length'] = nx.average_shortest_path_length(G)
else:
G.graph['char_path_length'] = 0
degrees = G.degree().values()
G.graph['max_degree'] = max(degrees)
G.graph['mean_degree'] = sum(degrees) / float(len(degrees))
G.graph['mode_degree'] = max(set(degrees), key=degrees.count)
G.graph['median_degree'] = stat.median(degrees)
G.graph['spectral_gap'] = pr_spectral_gap(G)
G.graph['heterogeneity'] = estrada_heterogeneity(G)
def analysis(self):
self.compute_density()
self.degree_correlation = nx.degree_assortativity_coefficient(self)
self.compute_complexity()
self.compute_paths()
self.compute_overlap()
self.compute_variance()
self.pattern_rank = numpy.linalg.matrix_rank(self.ideal_pattern)
self.binary_rank = numpy.linalg.matrix_rank(self.ideal_pattern > 0)
try:
self.compute_modularity()
except nx.NetworkXError:
pass
self.generate_random_ensemble()
self.compute_zscores()
with warnings.catch_warnings():
warnings.simplefilter("ignore", RuntimeWarning)
self.compute_essentialities()
def compute_measures(net):
output = {}
GCC = max((net.subgraph(c) for c in nx.connected_components(net)), key=len) # Giant component
output['Number of nodes'] = nx.number_of_nodes(net) #Number of nodes
output['Number of edges'] = nx.number_of_edges(net) #Number of edges
output['Network density'] = "%.2f"% nx.density(net) #Network density
output['Network diameter'] = nx.diameter(GCC) #Network diameter
output['Average shortest path'] = "%.2f"% nx.average_shortest_path_length(GCC) #Average shortest path
output['Average clustering coefficient'] = "%.2f"% nx.average_clustering(net, count_zeros=True) #Average clustering coefficient
output['Average degree'] = "%.2f"% (2*net.number_of_edges() / float(net.number_of_nodes())) #Average degree
output['Number of components in the network'] = len(list(net.subgraph(c) for c in nx.connected_components(net))) # Number of component in the network
output['Assortativity'] = "%.2f"% nx.degree_assortativity_coefficient(net) #Assortativity
output['Degree distribution'] = [net.degree(node) for node in nx.nodes(net)]
output['Clustering coeficient'] = list(nx.clustering(net).values())
return output
def main(fixtures):
out_file = open("cc.tsv", "a")
print("Repo",
"Average clustering",
"Degree assortativity",
"Transitivity",
sep="\t")
print("Repo",
"Average clustering",
"Degree assortativity",
"Transitivity",
sep="\t",
file=out_file)
# nx.draw(G, with_labels=True)
# plt.show()
repos = yield_repos(fixtures)
any(repo == "cuberite" for user, repo in repos)
for user, repo in repos:
print("Mining", user, repo, file=sys.stderr)
try:
path = os.path.join(fixtures, user, repo)
commits = mine_repo(path)
G = cc_graph(commits)
except KeyboardInterrupt:
print("Skipping", user, repo, file=sys.stderr)
else:
try:
out = [
repo,
nx.average_clustering(G),
nx.degree_assortativity_coefficient(G),
nx.transitivity(G)
]
except:
logging.exception(
"exception while computing graph coefficients")
else:
out = [str(o) for o in out]
print("\t".join(out))
print("\t".join(out), file=out_file, flush=True)
def manage_data(domain_name):
domain_pkts = get_data(domain_name)
node_cname, node_ip, visit_total, edges, node_main = get_ip_cname(domain_pkts[0]['details'])
for i in domain_pkts[0]['details']:
for v in i['answers']:
edges.append((v['domain_name'],v['dm_data']))
DG = nx.DiGraph()
DG.add_edges_from(edges)
ass = nx.degree_assortativity_coefficient(DG)
nodes_count = len(node_cname)+len(node_ip)+len(node_main)
print nodes_count
edges_count = len(edges)
average_degree = sum(nx.degree(DG).values())
print domain_name,ass
print nx.density(DG)
return nodes_count,edges_count, ass,average_degree,nx.degree_histogram(DG)
def analysis(G, output):
data = dict()
# data['clustering'] = nx.clustering(G, weight='weight')
# data['pagerank'] = nx.pagerank(G, weight='weight')
data['n_nodes'] = nx.number_of_nodes(G)
data['n_edges'] = nx.number_of_edges(G)
data['average_clustering'] = nx.average_clustering(G, weight='weight')
data['shortest_path_average'] = nx.average_shortest_path_length(
G, weight='weight')
data['degree_assortativity'] = nx.degree_assortativity_coefficient(
G, weight='weight')
with open(os.path.join(output, "analysis.json"), 'w') as out:
json.dump(data, out)
T = nx.maximum_spanning_tree(G, weight='weight')
fig = plt.figure(figsize=(20, 20))
nx.draw_kamada_kawai(T, node_color='#8ebad9')
plt.savefig(os.path.join(output, "mst.png"))
def compute_singlevalued_measures(ntwk,
weighted=True,
calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info("Computing single valued measures:")
measures = {}
iflogger.info("...Computing degree assortativity (pearson number) ...")
measures["degree_pearsonr"] = nx.degree_pearson_correlation_coefficient(
ntwk)
iflogger.info("...Computing degree assortativity...")
measures["degree_assortativity"] = nx.degree_assortativity_coefficient(
ntwk)
iflogger.info("...Computing transitivity...")
measures["transitivity"] = nx.transitivity(ntwk)
iflogger.info("...Computing number of connected_components...")
measures["number_connected_components"] = nx.number_connected_components(
ntwk)
iflogger.info("...Computing graph density...")
measures["graph_density"] = nx.density(ntwk)
iflogger.info("...Recording number of edges...")
measures["number_of_edges"] = nx.number_of_edges(ntwk)
iflogger.info("...Recording number of nodes...")
measures["number_of_nodes"] = nx.number_of_nodes(ntwk)
iflogger.info("...Computing average clustering...")
measures["average_clustering"] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info("...Calculating average shortest path length...")
measures[
"average_shortest_path_length"] = nx.average_shortest_path_length(
ntwk, weighted)
else:
iflogger.info("...Calculating average shortest path length...")
measures[
"average_shortest_path_length"] = nx.average_shortest_path_length(
nx.connected_component_subgraphs(ntwk)[0], weighted)
if calculate_cliques:
iflogger.info("...Computing graph clique number...")
measures["graph_clique_number"] = nx.graph_clique_number(
ntwk) # out of memory error
return measures
def calculate_network_params():
start_dir = self.ROOT_DIRECTORY + self.RESULT_DIRECTORY
dirs = next(os.walk(start_dir))[1]
for db_dir in dirs:
case_dir = next(os.walk(os.path.join(start_dir, db_dir)))[1]
if len(case_dir) != 0:
for dir in case_dir:
files = next(
os.walk(os.path.join(start_dir, db_dir, dir)))[2]
params = []
for kardio_file in files:
kardio_file_full_path = os.path.join(
start_dir, db_dir, dir, kardio_file)
f = open(kardio_file_full_path, 'rb')
graph = nx.read_gpickle(f)
params.append(
nx.average_clustering(graph, weight="weight"))
fw = open(
os.path.join(start_dir, db_dir,
dir + "clustering.txt"), "w")
for param in params:
fw.write("%s\n" % param)
else:
params = []
files = next(os.walk(os.path.join(start_dir, db_dir)))[2]
for kardio_file in files:
kardio_file_full_path = os.path.join(
start_dir, db_dir, kardio_file)
f = open(kardio_file_full_path, 'rb')
graph = nx.read_gpickle(f)
params.append(
nx.degree_assortativity_coefficient(
graph, weight="weight"))
try:
os.makedirs(os.path.join(start_dir, "assort"))
except:
pass
fw = open(
os.path.join(start_dir, "assort", db_dir + ".txt"),
"w")
for param in params:
fw.write("%s\n" % param)
def general_graph_statistic(self, G, top=5):
self.degree_statistic(G)
H = nx.Graph(G)
cc_list = list(nx.connected_components(H))
self.connected_components_statistic(cc_list)
self.cc_list_source_statistic(cc_list)
print('average_clustering: ', nx.average_clustering(H)) # 群聚系数
# print('diameter: ', nx.diameter(G)) # 直径
print('degree_assortativity_coefficient: ',
nx.degree_assortativity_coefficient(H)) # 同配性
dc_dict = nx.degree_centrality(H) # 度中心性，{node: degree_centrality}
print('degree_centrality top {}: '.format(top),
self.top_k_dict(dc_dict, top))
dc_dict = nx.eigenvector_centrality(H) # 特征向量中心性
print('eigenvector_centrality top {}: '.format(top),
self.top_k_dict(dc_dict, top))
dc_dict = nx.closeness_centrality(H) # 接近中心性
print('closeness_centrality top {}: '.format(top),
self.top_k_dict(dc_dict, top))
def calculate_clustering_coefficients_and_degree(feat, feat_ids):
node_wrt_feat_ids = dict([(x, []) for x in feat_ids])
for node in G.nodes:
if feat in G.nodes[node] and G.nodes[node][feat] in feat_ids:
node_wrt_feat_ids[G.nodes[node][feat]].append(node)
for c, x in enumerate(feat_ids):
print("Number of nodes of feature " + feat + " of id " + str(x) +
" is " + str(len(node_wrt_feat_ids[x])))
nds = [p for p in node_wrt_feat_ids[x]]
data = nx.clustering(G, nds)
clustering_coefficients_count = collections.Counter(
[round(data[x], 2) for x in nds])
print("CLUSTERING COEFFICIENT : " + feat + " " + str(x), end=' ')
print(clustering_coefficients_count)
clustering_coefficients, cnt = zip(*sorted(
clustering_coefficients_count.most_common(), key=lambda x: x[0]))
plt.figure(str(c) + 'clustering coefficients')
plt.loglog(clustering_coefficients, cnt, color='b')
plt.title("Clustering Coefficients " + feat + " " + str(x))
plt.ylabel("Count")
plt.xlabel("Clustering Coefficient")
degree_sequence = sorted(
[d for n, d in G.degree(node_wrt_feat_ids[x])], reverse=True)
degree_count = collections.Counter(degree_sequence)
print("DEGREE : " + feat + " " + str(x), end=' ')
print(degree_count)
deg, cnt = zip(*sorted(degree_count.items(), key=lambda x: x[0]))
plt.figure(str(c) + " degree")
plt.loglog(deg, cnt, color='b')
plt.title("Degree " + feat + " " + str(x))
plt.ylabel("Count")
plt.xlabel("Degree")
associativity = nx.degree_assortativity_coefficient(G, nodes=nds)
print("Associativity of feature " + feat + " of feature id " + str(x) +
" is " + str(associativity))
def main():
network_paths = [
"facebook-wosn-links_subgraph.edg", "karate_club_network_edge_file.edg"
]
network_names = ["facebook wosn", "karate_club_network"]
network_titles = ["facebook wosn", "karate club network"]
scatter_figure_base = 'graphs/scatter'
heatmap_figure_base = 'graphs/heatmap'
nearest_neighbor_figure_base = 'graphs/nearest_neighbors'
for network_path, network_name, network_title in zip(
network_paths, network_names, network_titles):
network = read_network(network_path)
degree_arrays = get_x_and_y_degrees(network)
create_scatter(degree_arrays, network_name, network_title,
scatter_figure_base)
create_heatmap(degree_arrays, network_name, network_title,
heatmap_figure_base)
assortativity_own = assortativity(degree_arrays)
assortativity_nx = nx.degree_assortativity_coefficient(network)
print("Own assortativity for " + network_title + ": " +
str(assortativity_own))
print("NetworkX assortativity for " + network_title + ": " +
str(assortativity_nx))
degrees, nearest_neighbor_degrees, = get_nearest_neighbor_degree(
network)
unique_degrees, mean_nearest_neighbor_degrees = get_simple_bin_average(
degrees, nearest_neighbor_degrees)
visualize_nearest_neighbor_degree(degrees, nearest_neighbor_degrees,
unique_degrees,
mean_nearest_neighbor_degrees,
network_name, network_title,
nearest_neighbor_figure_base)
def generate(User):
G = nx.Graph()
#User = User
#User = '******'
df = pd.read_csv(User, header=None, chunksize=100000)
for data in df:
for i in range(len(data)):
if data.ix[i, 3] != data.ix[i, 4]:
G.add_edges_from([(data.ix[i, 3], data.ix[i, 4])])
#nx.write_adjlist(G,'G_adjlist')
f0 = len(set(data[3])) #使用的计算机的数量
f1 = len(set(data[4])) #认证过的计算机的数量
f2 = len(G.nodes()) #图中节点的个数，去除重复f2 = f0+f1？
f3 = len(G.edges()) #图中边的个数，去除重复
f5 = nx.degree_histogram(G)[1] #节点度数为1 #孤立节点的个数
f6 = len(nx.degree_histogram(G)) - 1 #节点度数最大为几
f7 = nx.number_connected_components(G) #连通组件的个数
f8 = nx.average_clustering(G) #平均聚类系数
f9 = nx.average_node_connectivity(G) #节点的平均连通性
f10 = nx.density(G) #图密度
#--------------------------------------------------------
G = max(nx.connected_component_subgraphs(G), key=len)
#G = max(nx.connected_components(G), key=len)#
f11 = nx.average_shortest_path_length(G) #返回图G所有节点间平均最短路径长度。
f12 = nx.diameter(G) #返回图G的直径（最长最短路径的长度）
f13 = nx.radius(G) #半径
#f11 = nx.degree_centrality(G)#度中心性
#f12 = nx.betweenness_centrality(G)#介数中心性
f14 = nx.degree_assortativity_coefficient(
G) #调用 nx.degree_assortativity(G) 方法可以计算一个图的度匹配性。（同配性）
#L = [f0,f1,f2,f3,f4,f5,f6]
#L = [f0,f1,f2,f3,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,-1]#
return [f0, f1, f2, f3, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14,
-1] #*****
def compute_network_stats(G, inst):
print 'RECIP:%.5f' % reciprocity(G)
print 'MEAN_DEGREE:%.5f' % mean_degree(G)
print 'MEAN_NB_DEGREE:%.5f' % mean_nb_degree(G)
Gu = G.to_undirected()
print 'AVG_CLUSTER:%.5f' % nx.average_clustering(Gu)
print 'DEGREE_ASSORT:%.5f' % nx.degree_assortativity_coefficient(Gu)
print 'MEAN_GEODESIC:%.5f' % nx.average_shortest_path_length(Gu)
mg, d = mean_max_geodesic(Gu)
print 'MEAN_GEODESIC:%.5f' % mg
print 'DIAMETER:%d' % int(d)
keep = []
for n in Gu.nodes_iter():
if n in inst:
Gu.node[n]['region'] = inst[n]['Region']
keep.append(n)
H = Gu.subgraph(keep)
print 'MOD_REGION:%.5f' % (nx.attribute_assortativity_coefficient(H, 'region'))
def network_stats(yr_start,yr_end): ''' Returns a nested list of stats (year,interaction count,transitivity, characteristic path length, and assortativity. ''' pubs=num_pubs() stats=[[],[],[],[],[],[]] for year in range(yr_start,yr_end+1): ntwk=create_network(year,pubs) largest_component=nx.connected_component_subgraphs(ntwk)[0] stats[0].append(year) stats[1].append(len(ntwk.edges())) stats[2].append(nx.transitivity(ntwk)) stats[3].append(cpl(largest_component)) stats[4].append(nx.degree_assortativity_coefficient(ntwk)) stats[5].append(len(ntwk.edges())/float(20000)) return stats
def calculateMetricsForMonth2(year, month, G, output):
date = "20" + year + "-" + month + "-01"
#G = getMonthlyGraph(date)
N = len(G.nodes)
M = len(G.edges())
k = 2 * M / N
if M == 0:
#print("No matches for "+date)
output.put((year, month, -1, -1, -1, -1, -1, -1, -1))
else:
heterogenity_parameter = sum(
map(lambda y: y[1] * y[1], G.degree(G.nodes))) / (2 * M)
G2 = mgtg(G)
C = np.mean(list(nx.clustering(G2).values()))
r = nx.degree_assortativity_coefficient(G2)
# r['pearson'] = nx.degree_pearson_correlation_coefficient(G)
#Q = nx.algorithms.community.greedy_modularity_communities(G2)
Q1 = community.modularity(community.best_partition(G2), G2)
# G3 = buildNonIsolateNetwork(G2)
# Q_non_isolate = community.modularity(community.best_partition(G3), G3)
output.put((year, month, N, M, k, heterogenity_parameter, C, r, Q1))
def assortativity(self):
result = {}
result[
'degree_assortativity_coefficient'] = nx.degree_assortativity_coefficient(
self.graph)
if self.directed == 'undirected':
result[
'degree_pearson_correlation_coefficient'] = nx.degree_pearson_correlation_coefficient(
self.graph)
result['average_neighbor_degree'] = nx.average_neighbor_degree(
self.graph)
result['average_degree_connectivity'] = nx.average_degree_connectivity(
self.graph)
result['k_nearest_neighbors'] = nx.k_nearest_neighbors(self.graph)
fname_assort = self.DIR + '/assortativity.json'
with open(fname_assort, "w") as f:
json.dump(result, f, cls=SetEncoder, indent=2)
print(fname_assort)
def getStats(graph):
stats = dict()
stats["Nodes"] = nx.number_of_nodes(graph)
stats["Edges"] = nx.number_of_edges(graph)
stats["Neighbors/node"] = 2 * float(stats["Edges"])/ stats["Nodes"]
c = nx.average_clustering(graph)
stats["Clustering coefficient"] = "%3.2f"%c
try:
r = nx.degree_assortativity_coefficient(graph)
stats["Degree assortativity"] = "%3.2f"%r
r = get_assortativity_coeff(graph)
# stats["Degree assortativity - own"] = "%3.2f"%r
except:
print("Impossible to compute degree assortativity")
if (nx.is_connected(graph)):
stats['Diameter'] = nx.diameter(graph)
p = nx.average_shortest_path_length(graph)
stats["Characteristic path length"] = "%3.2f"%p
stats["Connected components"] = 1
else:
d = 0.0
p = 0.0
i = 0
for g in nx.connected_component_subgraphs(graph):
i += 1
d += nx.diameter(g)
if len(nx.nodes(g)) > 1:
p += nx.average_shortest_path_length(g)
p /= i
stats["Connected components"] = i
stats["Diameter - sum on cc"] = "%3.2f"%d
stats["Characteristic path length - avg on cc"] = "%3.2f"%p
dd = nx.degree_histogram(graph)
stats["Max degree"] = len(dd) - 1
return stats
def measure (filename) :
import table_printer as tp
from collections import namedtuple
G, terminals, nonterminals = parse(filename)
"""
print '%s terminals, sorted by ref count:' %len(terminals)
rows = []
Row = namedtuple('Row', ['name', 'referenced'])
for tok in terminals :
rows.append(Row("'%s'" %tok.name, tok.references))
rows.sort(key=lambda x: -x[1])
tp.print_table(rows)
print '\n%d nonterminals, sorted by num rules:' %len(nonterminals)
rows = []
Row = namedtuple('Row', ['name', 'rules', 'referenced'])
for nt in nonterminals :
rows.append(Row(nt.name, nt.rules, nt.references))
rows.sort(key=lambda x: -x[1])
tp.print_table(rows)
"""
num_rules = 0
for nt in nonterminals :
num_rules += nt.rules
print '\n%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s' %(
filename,
len(terminals),
len(nonterminals),
num_rules,
G.number_of_nodes(),
G.number_of_edges(),
G.number_of_edges() * 1.0 / G.number_of_nodes(),
nx.average_clustering(G.to_undirected()),
nx.average_shortest_path_length(G),
nx.degree_assortativity_coefficient(G))
return G
def process_igraph(G, n_networks, mean_matrix, line):
n_nodes_list = list()
avg_degree_list = list()
smd_distribution_list = list()
avg_shortest_list = list()
avg_clustering_list = list()
transitivity_list = list()
assortativity_list = list()
for i in range(0, n_networks):
Gi = nx.Graph([edge.tuple for edge in G[i].es])
N = len(Gi)
M = Gi.number_of_edges()
n_nodes_list.append(N)
avg_degree_list.append(2 * M / N)
smd_distribution_list.append(second_momment_of_degree_distribution(Gi))
avg_shortest_list.append(nx.average_shortest_path_length(Gi))
avg_clustering_list.append(nx.average_clustering(Gi))
transitivity_list.append(nx.transitivity(Gi))
assortativity_list.append(nx.degree_assortativity_coefficient(Gi))
a = np.array(n_nodes_list)
mean_matrix[line][0] = np.mean(a)
a = np.array(avg_degree_list)
mean_matrix[line][1] = np.mean(a)
a = np.array(smd_distribution_list)
mean_matrix[line][2] = np.mean(a)
a = np.array(avg_shortest_list)
mean_matrix[line][3] = np.mean(a)
a = np.array(avg_clustering_list)
mean_matrix[line][4] = np.mean(a)
a = np.array(transitivity_list)
mean_matrix[line][5] = np.mean(a)
a = np.array(assortativity_list)
mean_matrix[line][6] = np.mean(a)
def get_stats(files, path=''):
results = []
for i in files:
G = nx.read_pajek(path + i)
numbNodes = G.number_of_nodes()
numbEdges = G.number_of_edges()
degrees = nx.degree(G).values()
clustering = nx.clustering(nx.Graph(G)).values()
assortativity = nx.degree_assortativity_coefficient(G)
average_path, diameter = average_path_calculation(G)
data_results = (i, numbNodes, numbEdges, np.mean(degrees),
max(degrees), min(degrees), np.mean(clustering),
assortativity, average_path, diameter)
results.append(data_results)
print i + ' done'
return results
def save_metrics(): global density,clustering,assortativity,initial_edges,impact,degree, avg_neigh_degree, initial_edges global ranked_nodes, ranked_degrees,degree_final,node_final, moving new_edges=list(RGG.edges()) intersect = [filter(lambda x: x in new_edges, sublist) for sublist in initial_edges] impact.append(len(new_edges)-len(intersect)) density.append(round(nx.density(RGG),2)) clustering.append(round(nx.average_clustering(RGG),2)) assortativity.append(round(nx.degree_assortativity_coefficient(RGG),2)) degree.append(RGG.degree(moving)) avg_neigh_degree.append(round(nx.average_neighbor_degree(RGG,nodes=[moving]).values()[0],2)) degree_set=[] node_name=[] for i in RGG.nodes(): degree_set.append(RGG.degree(i)) node_name.append(i) degree_final.append(degree_set) node_final.append(node_name) degree_set,node_name=zip(*sorted(zip(degree_set,node_name))) ranked_degrees.append(degree_set) ranked_nodes.append(node_name)
def analyze_network(G: nx.Graph, name) -> None:
M = nx.to_numpy_array(G)
dac = nx.degree_assortativity_coefficient(G)
clustering_coefficients = nx.clustering(G)
node_to_degree = make_node_to_degree(M)
edge_density = calc_edge_density(M)
print(f'Edge density: {edge_density}')
if nx.is_connected(G):
diameter = nx.diameter(G)
else:
largest_component = max(nx.connected_components(G), key=len)
largest_subgraph = G.subgraph(largest_component)
diameter = nx.diameter(largest_subgraph)
print(f'Diameter: {diameter}')
print(f'Degree assortativity coefficient: {dac}')
show_clustering_coefficent_dist(
clustering_coefficients, # type: ignore
dict(enumerate(node_to_degree)))
# components = get_components(G)
# print(f'size of components: {[len(comp) for comp in components]}')
show_deg_dist_from_matrix(M, name, display=False, save=False)
def compute_singlevalued_measures(ntwk, weighted=True, calculate_cliques=False):
"""
Returns a single value per network
"""
iflogger.info('Computing single valued measures:')
measures = {}
iflogger.info('...Computing degree assortativity (pearson number) ...')
try:
measures['degree_pearsonr'] = nx.degree_pearsonr(ntwk)
except AttributeError: # For NetworkX 1.6
measures['degree_pearsonr'] = nx.degree_pearson_correlation_coefficient(ntwk)
iflogger.info('...Computing degree assortativity...')
try:
measures['degree_assortativity'] = nx.degree_assortativity(ntwk)
except AttributeError:
measures['degree_assortativity'] = nx.degree_assortativity_coefficient(ntwk)
iflogger.info('...Computing transitivity...')
measures['transitivity'] = nx.transitivity(ntwk)
iflogger.info('...Computing number of connected_components...')
measures['number_connected_components'] = nx.number_connected_components(ntwk)
iflogger.info('...Computing graph density...')
measures['graph_density'] = nx.density(ntwk)
iflogger.info('...Recording number of edges...')
measures['number_of_edges'] = nx.number_of_edges(ntwk)
iflogger.info('...Recording number of nodes...')
measures['number_of_nodes'] = nx.number_of_nodes(ntwk)
iflogger.info('...Computing average clustering...')
measures['average_clustering'] = nx.average_clustering(ntwk)
if nx.is_connected(ntwk):
iflogger.info('...Calculating average shortest path length...')
measures['average_shortest_path_length'] = nx.average_shortest_path_length(ntwk, weighted)
else:
iflogger.info('...Calculating average shortest path length...')
measures['average_shortest_path_length'] = nx.average_shortest_path_length(nx.connected_component_subgraphs(ntwk)[0], weighted)
if calculate_cliques:
iflogger.info('...Computing graph clique number...')
measures['graph_clique_number'] = nx.graph_clique_number(ntwk) #out of memory error
return measures
def main(args):
if len(args) == 0:
print "Usage: python network_stats.py <infile>"
sys.exit()
infile = args[0]
if infile.endswith(".gml"):
g = networkx.read_gml(infile)
elif infile.endswith("graphml"):
g = networkx.read_graphml(infile)
else:
print "Unknown file extension"
sys.exit(1)
n = len(g.nodes())
m = len(g.edges())
print "number of vertices = %d" %(n)
print "number of edges = %d" %(m)
print "average degree = %f" %(numpy.average(g.degree().values()))
print "number of components = %d" \
%(networkx.number_connected_components(g))
print "average clustering coefficient = %f" \
%(networkx.average_clustering(g))
print "assortativity coefficient = %f" \
%(networkx.degree_assortativity_coefficient(g))
def metrics(G):
# drawing the full network
plot_graph(G)
show()
print(nx.info(G))
clos = nx.closeness_centrality(G).values()
bet = nx.betweenness_centrality(G, normalized=True).values()
print("isolated nodes: ", nx.number_of_isolates(G))
print("Density:", nx.density(G))
print("Diameter:", nx.diameter(G))
print("Connectivity:", nx.node_connectivity(G))
print("Average short path", nx.average_shortest_path_length(G))
print("Assortativity:", nx.degree_assortativity_coefficient(G))
giant = sorted(nx.connected_component_subgraphs(G), key=len, reverse=True)
print("Size of biggest GCC (nodes): ", giant[0].order())
print("Max betweeness", np.max(np.array(list(bet))))
print("Max closeness", np.max(np.array(list(clos))))
print("AVG betweeness", np.mean(np.array(list(bet))))
print("AVG closeness", np.mean(np.array(list(clos))))
PlotMostImp(G)
def main(args):
if len(args) == 0:
print "Usage: python network_stats.py <infile>"
sys.exit()
infile = args[0]
if infile.endswith(".gml"):
g = networkx.read_gml(infile)
elif infile.endswith("graphml"):
g = networkx.read_graphml(infile)
else:
print "Unknown file extension"
sys.exit(1)
n = len(g.nodes())
m = len(g.edges())
print "number of vertices = %d" % (n)
print "number of edges = %d" % (m)
print "average degree = %f" % (numpy.average(g.degree().values()))
print "number of components = %d" \
%(networkx.number_connected_components(g))
print "average clustering coefficient = %f" \
%(networkx.average_clustering(g))
print "assortativity coefficient = %f" \
%(networkx.degree_assortativity_coefficient(g))
def getInfo(self):
# get the number of nodes and edges in the graph
print "# of nodes in %s: %d" % (self.graphName, self.snapG.GetNodes())
print "# of edges in %s: %d" % (self.graphName, self.snapG.GetEdges())
print "[Metric] Density: %f | G(%d,%d)" % (nx.density(
self.nxG), nx.number_of_nodes(
self.nxG), nx.number_of_edges(self.nxG))
print "\n[Node stat]"
counterN = 0
p = 1
for key in self.lblNH:
counterN += self.lblNH[key]
cp = float(self.lblNH[key]) / self.G.GetNodes()
if (p >= cp):
p = cp
print "Label: %s, # of nodes: %d, percentage: %f" % (
key, self.lblNH[key], cp)
print "Total Nodes %d" % (counterN)
print "\n[Edge stat]"
counterE = 0
for key in self.lblEH:
counterE += self.lblEH[key]
cp = float(self.lblEH[key]) / self.snapG.GetEdges()
print "Label: %d, # of edges: %d, percentage: %f" % (
key, self.lblEH[key], cp)
print "Total Edges %d" % (counterE)
# p=float(min(self.lblNH[0],self.lblNH[1])) / self.G.GetNodes()
RB = float(self.lblEH[2]) / self.snapG.GetEdges()
tau = 1 - (RB / (2 * p * (1 - p)))
print "[Estimation] p: %f, tau: %f" % (p, tau)
print "[Metric] Degree_assortativity_coefficient: %f" % nx.degree_assortativity_coefficient(
self.nxG)
print "[Metric] Transitivity: %f" % nx.transitivity(self.nxG)
def test_degree_assortativity_fully_assortative_binary(self):
adjacency = {
1: [],
2: [],
3: [],
4: [5, 6],
5: [6],
6: [],
7: [8, 9, 10],
8: [9, 10],
9: [10],
10: []
}
edge_list = adjacency_to_edge_list(adjacency)
reader = GraphReader(edge_list=edge_list)
double_adjacency = reader.double_adjacency()
computed_assortativity = self.assortativity.compute_degree_assortativity(
double_adjacency)
# this is the expected input format in networkx
vertex_ids = adjacency.keys()
edge_list = adjacency_to_edge_list(adjacency)
networkx_graph = nx.Graph() # using undirected graphs
networkx_graph.add_nodes_from(vertex_ids)
networkx_graph.add_edges_from(edge_list)
correct_assortativity = nx.degree_assortativity_coefficient(
networkx_graph)
np.testing.assert_approx_equal(
computed_assortativity,
correct_assortativity,
err_msg=
"Assortativity score mismatch in a binary graph without self-edges, that should be fully assortative"
)
def main(args):
if len(args) == 0:
print "Usage: python network_stats.py <infile>"
sys.exit()
infile = args[0]
g = networkx.read_graphml(infile)
n = len(g.nodes())
m = len(g.edges())
print "number of vertices = %d" %(n)
print "number of edges = %d" %(m)
print "connectance = %f" %(1.0 * m / (n * (n - 1) / 2))
print "average degree = %f" %(numpy.average(g.degree().values()))
components = networkx.connected_components(g)
print "number of components = %d" %(len(components))
print "fractional size of largest component = %f" \
%(max([len(i) * 1. for i in components]) / \
len(g.nodes()))
if len(components) == 1:
print "diameter = %f" %(networkx.average_shortest_path_length(g))
else:
print "diameter = infinity"
print "average clustering coefficient = %f" \
%(networkx.average_clustering(g))
print "homophily = %f" %(networkx.degree_assortativity_coefficient(g))
def calc_assortativity_coefficient(g, dest_file):
"""
calc_assortativity_coefficient(g)
Calculate & plot the assortativity coefficient of the graph g using inbuilt NetworkX functions,
Writes data to the created data output file
:param g: graph as source
:return: ---
"""
func_intro = "\n\nAssortativity Co-Efficient ..."
logging.info(cs_ref, func_intro)
print func_intro
with open(dest_file, "a") as dat_file:
dat_file.write(func_intro)
dac = nx.degree_assortativity_coefficient(g) # calculate assortativity coefficient
with open(dest_file, "a") as dat_file:
dat_file.write("\n\tDegree Assortativity Co-efficient = \t" + str(dac))
A = nx.to_scipy_sparse_matrix(g) # plot assortativity coefficient
plt.figure(2)
plt.spy(A)
plt.title("Assortativity Co-efficient" + src_file)
plt.savefig("plots/cs1_assortativity_coefficient.png")
plt.show()
for g in graphs.keys():
try:
print "====================== " , g, "==========================="
print "number of isolated nodes",'\t\t\t',nx.isolates(graphs[g])
print "is graph biconnected?",'\t\t\t',nx.is_biconnected(graphs[g])
print "cut vertices are: ",'\t\t\t',list(nx.articulation_points(graphs[g]))
print "number of nodes",'\t\t\t',len(graphs[g].nodes())
print "number of edges",'\t\t\t',len(graphs[g].edges())
print "degree",'\t\t\t',get_avg(graphs[g].degree())
print "diameter",'\t\t\t', nx.diameter(graphs[g])
print "radius",'\t\t\t', nx.radius(graphs[g])
print "is_bipartite?",'\t\t', bipartite.is_bipartite(graphs[g])
print "average_shortest_path_length",'\t\t', nx.average_shortest_path_length(graphs[g])
print "degree_assortativity_coefficient",'\t\t', nx.degree_assortativity_coefficient(graphs[g])
print "assortativity.average_degree_connectivity",'\t\t', nx.assortativity.average_degree_connectivity(graphs[g])
#print "degree_pearson_correlation_coefficient",'\t\t', nx.degree_pearson_correlation_coefficient(graphs[g])
print "node closeness_centrality",'\t\t\t', get_avg(nx.closeness_centrality(graphs[g]))
print "clustering",'\t\t\t', get_avg(nx.clustering(graphs[g]))
print "node betweeness",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=False,endpoints=False))
print "edge betweeness",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=False))
#print "spectral_bipartivity",'\t\t', bipartite.spectral_bipartivity(graphs[g])
#print "node betweeness normalized",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=True,endpoints=False))
#print "edge betweeness normalized",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=True))
#print "node closeness_vitality",'\t\t\t', get_avg(nx.closeness_vitality(graphs[g]))
#print "communicability_centrality",'\t\t', get_avg(nx.communicability_centrality(graphs[g]))
#print "communicability_betweenness_centrality",'\t\t', get_avg(nx.communicability_betweenness_centrality(graphs[g]))
#print "transitivity",'\t\t\t', round(nx.transitivity(graphs[g]),4)
#print "laplacian_spectrum",'\t\t\n:', nx.laplacian_spectrum(graphs[g])
print "adjacency_spectrum",'\t\tMin 5 :', get_min(nx.adjacency_spectrum(graphs[g])) , "\t\tMax 5 :",get_max(nx.adjacency_spectrum(graphs[g]))
filename = "TF_analysis.csv" csvfile = open(filename) #1~300 # print G.node for row in csv.reader(csvfile): G.add_edges_from([(row[0],row[1])],weight=row[2]) print "average_neighbor_degree" print nx.average_neighbor_degree(G) print "degree_assortativity_coefficient" print nx.degree_assortativity_coefficient(G) print "degree_pearson_correlation_coefficient" print nx.degree_pearson_correlation_coefficient(G) #print nx.k_nearest_neighbors(G) print "bipartite.closeness_centrality" print bipartite.closeness_centrality(G,G.node) print "degree_centrality" print nx.degree_centrality(G) print "betweenness_centrality" print nx.betweenness_centrality(G)
def get_example_assortativity_coeffs(): l = [] for k in examples_list: G = msd.readFeederData(k) l += [nx.degree_assortativity_coefficient(G)] return l
def degree_assortativity_coefficientFunction():
return nx.degree_assortativity_coefficient(Graph)
def deg_assortativity_coefficient(self): #f-24
return nx.degree_assortativity_coefficient(self.ng)
def degree_assortativity(G):
return round(nx.degree_assortativity_coefficient(G), DECIMALS)
# The branching is calculated as P2/P1
# The intermodular connectivity as P3/P2
suma1=0
P2=0
for key in d:
suma1+=int(d[key])
P2+=nCk(int(d[key]),2)
P1=suma1*0.5
C3=C*P2/3.0
suma=0
for u,v in net.edges():
suma=suma+(d[u]-1)*(d[v]-1)
P3=suma-3*C3
P21=float(P2)/float(P1)
P32=float(P3)/float(P2)
# Conditions for assortativity and disassortativity
if P32 + C > P21:
print("The network is assortative with r = "+str(nx.degree_assortativity_coefficient(net)))
elif P32 + C < P21:
print("The network is disassortative with r = "+str(nx.degree_assortativity_coefficient(net)))
else:
print("The network is neutral with r = "+str(nx.degree_assortativity_coefficient(net)))
print("The relative branching is: " + str(P21))
print("The intermodular connectivity is: " + str(P32))
print("The transitivity is: " + str(C))
"""
awk 'if $3 > threshold {print $1, $2}' SR_0x > SRUNW
"""
def run(self, G): ac = networkx.degree_assortativity_coefficient(G) return ac
def Connected_Prediction_Main(Predictor, fnid):
try:
fnobj = open(fnid,'r')
except IOError as e:
print "***file open error:",e
else:
#**************Read data and Create graph*******************
G = nx.Graph()
eline = fnobj.readline()
eline = fnobj.readline()
while eline:
line = eline.strip().split()
#print line
#edge = (line[0],line[1],line[2],line[3])
#Edge.append(tep)
if G.has_edge(string.atoi(line[0]),string.atoi(line[1])):
G[string.atoi(line[0])][string.atoi(line[1])]['weight'] = G[string.atoi(line[0])][string.atoi(line[1])]['weight'] + string.atof(line[2])
if G[string.atoi(line[0])][string.atoi(line[1])]['timestamp'] < string.atof(line[3]):
G[string.atoi(line[0])][string.atoi(line[1])]['timestamp'] = string.atof(line[3])
else:
G.add_edge(string.atoi(line[0]),string.atoi(line[1]),weight=string.atof(line[2]),timestamp=string.atof(line[3]))
eline = fnobj.readline()
#end while
################################################
partition = lw.best_partition(G)
print partition.keys()
DrawGraph = {}
for nid in partition.keys():
if DrawGraph.has_key(partition[nid]):
DrawGraph[partition[nid]].append(nid)
else:
DrawGraph[partition[nid]] = [nid]
#enf for
print len(DrawGraph)
for com in DrawGraph.keys():
print com,len(DrawGraph[com])
#print DrawGraph[5]
#-------------------------------------------------
for com in DrawGraph.keys():
if com != 17:
for node in DrawGraph[com]:
G.remove_node(node)
#end for
print G.number_of_nodes()
###################################################
#********Split data into training data and test data*******
Edges_Set = G.edges(data=True)
#print Edges_Set
Sorted_Edges_Set = sorted(Edges_Set, key=lambda edge: edge[2]['timestamp'])
#print Sorted_Edges_Set
Top_L = int(len(Sorted_Edges_Set)*0.08)
#Training_Set = Sorted_Edges_Set[:-(Top_L+1)]
Test_Set = Sorted_Edges_Set[-Top_L:]
#print Test_Set
#-------------------------------------------
#*****Ensuring the greatest component of training network structure******
for edge in Test_Set:
G.remove_edge(edge[0],edge[1])
if nx.is_connected(G) == False:
### Get the Greatest Component of Networks #####
components = sorted(nx.connected_components(G), key = len, reverse=True)
print len(components)
for i in range(1, len(components)):
for node in components[i]:
G.remove_node(node)
#end for
print nx.is_connected(G)
print G.number_of_nodes()
#end if------------------------------
#*****Ensuring the training data and test data have the same nodes set******
Probe_Set = []
for i in range(0, len(Test_Set)):
if G.has_node(Test_Set[i][0]) and G.has_node(Test_Set[i][1]):
if G.has_edge(Test_Set[i][0], Test_Set[i][1]):
print "ERROR: overlapping links in training data and test data"
else:
Probe_Set.append((Test_Set[i][0],Test_Set[i][1], Test_Set[i][2]['timestamp']))
#end for
Top_L = len(Probe_Set)
print "len(Probe_Set):",len(Probe_Set)
print "len(Test_Set):",len(Test_Set)
print "len(G.edges()):",len(G.edges())
print "len(G.nodes()):",len(G.nodes())
#print Test_Set
#####*********Statistic attributes of graphs*************
print "*Statistic attributes of graphs:"
print "N", nx.number_of_nodes(G)
print "M", nx.number_of_edges(G)
print "C", nx.average_clustering(G)
print "Cw", nx.average_clustering(G, weight='weight')
print "<d>", nx.average_shortest_path_length(G)
print "r", nx.degree_assortativity_coefficient(G)
#print nx.density(G)
#print nx.transitivity(G)
degree_list = list(G.degree_iter())
#print degree_list
avg_degree_1 = 0.0
avg_degree_2 = 0.0
for node in degree_list:
avg_degree_1 = avg_degree_1 + node[1]
avg_degree_2 = avg_degree_2 + node[1]*node[1]
avg_degree = avg_degree_1/len(degree_list)
avg_degree_square = (avg_degree_2/len(degree_list)) / (avg_degree*avg_degree)
print "<k>", avg_degree
print "H", avg_degree_square
#Regularization
#for edge in G.edges(data=True):
# edge[2]['weight'] = 1#math.exp( -1 / edge[2]['weight'] ) + math.exp( -1 / edge[2]['timestamp'] )
#end for
#*******************************************************************************#
print fnid
#print "============Native_Prediction_Experiment==============================="
#Drift_Prediction_Experiment(G, Predictor, Probe_Set, Top_L, 3.0)
#Prediction_Experiment(G, Predictor, Probe_Set, Top_L, 3.0) #Top_K, Deleted_Ratio
#print "============Drift_Prediction_Experiment==============================="
#G = Position_Drift.Graph_Spatial_Temporal_Dynamics(G, 3) #Spatial_Temporal influence based node position drift.
#Prediction_Experiment(G, Predictor, Probe_Set, Top_L, 3.0) #Top_K, Deleted_Ratio
Drift_Prediction_Experiment(G, Predictor, Probe_Set, Top_L, 2.5)