def get_graph_parameters(file_name):
'''
11 months
4 parameters: density ,assortativity,clustering coefficient, , number of triads
'''
params = np.zeros([11, 4])
with open(file_name) as fp:
month_nets = json.load(fp)
for ii in range(11):
network = month_nets[ii]
keys = network.keys()
usr_dict = get_dict(network)
G = nx.DiGraph()
for i in range(len(usr_dict)):
G.add_node(i)
for i in range(len(network)):
ls = network[keys[i]]
for j in range(len(ls)):
G.add_edge(usr_dict[keys[i]], usr_dict[ls[j]])
e = G.number_of_edges()
v = G.number_of_nodes()
density = e / float((v * (v - 1)))
assort = nx.algorithms.assortativity.degree_assortativity_coefficient(
G)
cc = nx.algorithms.average_clustering(G)
Gb = snap.TNGraph.New()
keys_b = usr_dict.keys()
for i in range(len(usr_dict)):
Gb.AddNode(i)
for i in range(len(network)):
ls = network[keys[i]]
for j in range(len(ls)):
Gb.AddEdge(usr_dict[keys[i]], usr_dict[ls[j]])
triads = snap.GetTriads(Gb)
params[ii, 0] = density
params[ii, 1] = assort
params[ii, 2] = cc
params[ii, 3] = triads
return params
#%%
params_r = {}
for i in range(n):
print(i)
params_r[files[i]] = get_graph_parameters(dir_c + files[i])
def clustering_coefficient():
# Count triads
Triads = snap.GetTriads(G)
print("# of triads", Triads)
# Calculate clustering coefficient
CC = snap.GetClustCf(G)
print("clustering coefficient", CC)
def print_info(graph):
for NI in graph.Nodes():
print("node: %d, out-degree %d, in-degree %d" %
(NI.GetId(), NI.GetOutDeg(), NI.GetInDeg()))
print("Number of nodes: ", graph.GetNodes())
print("Number of edges: ", graph.GetEdges())
print("Maximum degree: ", graph.GetNI(snap.GetMxDegNId(graph)).GetDeg())
print("Diameter (approximate): ", snap.GetBfsFullDiam(graph, 10))
print("Triangles: ", snap.GetTriads(graph))
print("Clustering coefficient: ", snap.GetClustCf(graph))
def getBasicProps(graph):
# Assuming unweighted undirected graph
return {
'num_nodes': graph.GetNodes(),
'num_edges': graph.GetEdges(),
'avg_deg': 2. * graph.GetEdges() / graph.GetNodes(),
'gamma': getGamma(graph),
'deg_centr': getDegCentr(graph),
'num_tris': snap.GetTriads(graph, -1),
'global_cc': snap.GetClustCf(graph, -1),
}
def processNetwork(Graph, id_to_groups):
with open("../../data/fastinf_graph_noweights_features.txt", "w+") as f:
f.write("RELATED GROUPS GRAPH:\n")
f.write('Edges: %d\n' % Graph.GetEdges())
f.write('Nodes: %d\n\n' % Graph.GetNodes())
MxWcc = snap.GetMxWcc(Graph)
f.write("MAX WCC:\n")
f.write('Edges: %f ' % MxWcc.GetEdges())
f.write('Nodes: %f \n' % MxWcc.GetNodes())
f.write('Node List: ')
for node in MxWcc.Nodes():
f.write('%d, ' % node.GetId())
f.write('\n')
for node in MxWcc.Nodes():
f.write('%s, ' % id_to_groups[node.GetId()])
f.write("\n\nALL WCCs:")
Components = snap.TCnComV()
snap.GetWccs(Graph, Components)
for i, CnCom in enumerate(Components):
if CnCom.Len() < 10: continue
f.write('\nWcc%d: ' % i)
for nodeid in CnCom:
f.write('%d, ' % nodeid)
MxScc = snap.GetMxScc(Graph)
f.write("\n\nMAX SCC:\n")
f.write('Edges: %f ' % MxScc.GetEdges())
f.write('Nodes: %f \n' % MxScc.GetNodes())
f.write('Node List: ')
for node in MxScc.Nodes():
f.write('%d, ' % node.GetId())
f.write('\n')
for node in MxScc.Nodes():
f.write('%s, ' % id_to_groups[node.GetId()])
f.write("\n\nALL SCCs:")
Components = snap.TCnComV()
snap.GetSccs(Graph, Components)
for i, CnCom in enumerate(Components):
if CnCom.Len() < 10: continue
f.write('\nScc%d: ' % i)
for nodeid in CnCom:
f.write('%d, ' % nodeid)
f.write('\n\nCLUSTERING AND COMMUNITIES:\n')
f.write('Clustering coefficient: %f\n' % snap.GetClustCf(Graph, -1))
f.write('Num Triads: %d\n' % snap.GetTriads(Graph, -1))
Nodes = snap.TIntV()
for node in Graph.Nodes():
Nodes.Add(node.GetId())
f.write('Modularity: %f' % snap.GetModularity(Graph, Nodes))
def print_number_of_traids_participated_by_random_node(G, GName):
TriadV = snap.TIntTrV()
snap.GetTriads(G, TriadV)
random_traid_node_index = snap.TInt.GetRnd(len(TriadV))
counter = 0
for triple in TriadV:
if counter == random_traid_node_index:
print "Number of traids of random node {0} participates in {1}: {2}".format(
triple.Val1(), GName[:-10], triple.Val2())
break
counter = counter + 1
number_of_edges_in_traids = snap.GetTriadEdges(G)
print "Number of edges that participate in at least one triad in {0}: {1}".format(
GName[:-10], number_of_edges_in_traids)
def print_connectivity_clustering(G):
"""
Prints the average clustering coefficient, number of triads in subgraph G
Also prints clustering coefficient and number of triads for random nodes
Also prints the number of edges that participate in at least one triad
"""
GraphClustCoeff = snap.GetClustCf(G)
print("Average clustering coefficient:", round(GraphClustCoeff, 4))
print("Number of triads:", snap.GetTriads(G))
NId = G.GetRndNId()
print(f'Clustering coefficient of random node {NId}:', round(snap.GetNodeClustCf(G, NId)))
NId = G.GetRndNId()
print(f'Number of triads random node {NId} participates:', snap.GetNodeTriads(G, NId))
print('Number of edges that participate in at least one triad:', snap.GetTriadEdges(G))
def getUniqueTriads(G):
'''
:param - G: graph
return type: Iterator, triplets identifying unique triads (only one set per triad)
return: Return all triads in G.
'''
seenTriads = {}
for node in G.Nodes():
neighbors = [G.GetNI(node.GetNbrNId(i)) for i in xrange(node.GetDeg())]
for neighbor in neighbors:
for i in xrange(neighbor.GetDeg()):
candidate = neighbor.GetNbrNId(i)
if node.IsNbrNId(candidate):
triad = tuple(
sorted([node.GetId(),
neighbor.GetId(), candidate]))
if triad not in seenTriads:
seenTriads[triad] = True
yield triad
assert len(seenTriads) == snap.GetTriads(G)
def computeTriadCounts(G, signs):
"""
:param - G: graph
:param - signs: Dictionary of signs (key = node pair (a,b), value = sign)
return type: List, each position representing count of t0, t1, t2, and t3, respectively.
return: Return the counts for t0, t1, t2, and t3 triad types. Count each triad
only once and do not count self edges.
"""
# each position represents count of t0, t1, t2, t3, respectively
triad_count = [0, 0, 0, 0]
############################################################################
mapping = {-1: 0, 1: 1}
for triad in getUniqueTriads(G):
index = sum(
[mapping[signs[(triad[i], triad[i + 1])]] for i in range(-1, 2)])
triad_count[index] += 1
assert snap.GetTriads(G) == sum(triad_count)
############################################################################
return triad_count
def calculate(self):
"""
Calculates the metrics on the network using both networkx and snap
:return: self
"""
self.calculate_basic()
print "calculating clustering coefficient."
self.clustering_coeff = snap.GetClustCf(self.g_snap, -1)
print "calculating transitivity"
self.transitivity = nx.transitivity(self.g_nx)
print "calculating triads"
self.num_triads = snap.GetTriads(self.g_snap, -1)
print "calculating diameter"
self.diameter = snap.GetBfsFullDiam(self.g_snap, 150, False)
print "calculating spl"
self.avg_spl = self.calculate_spl()
return self
e = int(e * p)
SumDeg = 0
#problem1
#1
Graph = snap.GenRndGnm(snap.PUNGraph, n, e)
InDegV = snap.TIntPrV()
snap.GetNodeInDegV(Graph, InDegV)
for item in InDegV:
SumDeg += item.Val2()
MeanDeg = SumDeg / n
a = pow(MeanDeg, 3) / 6
TriadV = snap.TIntTrV()
snap.GetTriads(Graph, TriadV, -1)
OpenTriads = 0
ClosedTriads = 0
for triple in TriadV:
OpenTriads += triple.Val3()
ClosedTriads += triple.Val2()
ClosedTriads = ClosedTriads / 3
TotalTriads = (3.0 * ClosedTriads) + OpenTriads
GlobalClcf = (3.0 * ClosedTriads) / TotalTriads
print 'number of nodes:', n
print 'number of edges', e
print 'number of open tri %d closed tri %d total tri %d' % (
OpenTriads, ClosedTriads, TotalTriads)
print "size %d: count %d" % (p.GetVal1(), p.GetVal2())
# get degree distribution pairs (out-degree, count):
snap.GetOutDegCnt(G9, CntV)
for p in CntV:
print "degree %d: count %d" % (p.GetVal1(), p.GetVal2())
# generate a Preferential Attachment graph on 100 nodes and out-degree of 3
G10 = snap.GenPrefAttach(100, 3)
print "G10: Nodes %d, Edges %d" % (G10.GetNodes(), G10.GetEdges())
# define a vector of floats and get first eigenvector of graph adjacency matrix
EigV = snap.TFltV()
snap.GetEigVec(G10, EigV)
nr = 0
for f in EigV:
nr += 1
print "%d: %.6f" % (nr, f)
# get an approximation of graph diameter
diam = snap.GetBfsFullDiam(G10, 10)
print "diam", diam
# count the number of triads:
triads = snap.GetTriads(G10)
print "triads", triads
# get the clustering coefficient
cf = snap.GetClustCf(G10)
print "cf", cf
from snap import *
import snap
import sys
# create a graph PUNGraph (undirected graph)
G1 = TUNGraph.New()
# read in vertices
numVertices = 0
textFile = open('vertices_' + str(sys.argv[1]) + '.txt')
lines = textFile.readlines()
for line in lines:
stripped_line = line.rstrip('\n')
G1.AddNode(int(stripped_line))
numVertices = numVertices + 1
# read in edges
with open('edges_' + str(sys.argv[1]) + '.txt') as f:
for line in f:
int_list = [int(i) for i in line.split()]
G1.AddEdge(int_list[0],int_list[1])
NumTriads = snap.GetTriads(G1, numVertices)
strValue = str.format("{0:.10f}", NumTriads)
f = open('triangles_' + str(sys.argv[1]) + '.txt', 'w')
f.write(str(strValue))
def intro():
# create a graph PNGraph
G1 = snap.TNGraph.New()
G1.AddNode(1)
G1.AddNode(5)
G1.AddNode(32)
G1.AddEdge(1, 5)
G1.AddEdge(5, 1)
G1.AddEdge(5, 32)
print("G1: Nodes %d, Edges %d" % (G1.GetNodes(), G1.GetEdges()))
# create a directed random graph on 100 nodes and 1k edges
G2 = snap.GenRndGnm(snap.PNGraph, 100, 1000)
print("G2: Nodes %d, Edges %d" % (G2.GetNodes(), G2.GetEdges()))
# traverse the nodes
for NI in G2.Nodes():
print("node id %d with out-degree %d and in-degree %d" %
(NI.GetId(), NI.GetOutDeg(), NI.GetInDeg()))
# traverse the edges
for EI in G2.Edges():
print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId()))
# traverse the edges by nodes
for NI in G2.Nodes():
for Id in NI.GetOutEdges():
print("edge (%d %d)" % (NI.GetId(), Id))
# generate a network using Forest Fire model
G3 = snap.GenForestFire(1000, 0.35, 0.35)
print("G3: Nodes %d, Edges %d" % (G3.GetNodes(), G3.GetEdges()))
# save and load binary
FOut = snap.TFOut("test.graph")
G3.Save(FOut)
FOut.Flush()
FIn = snap.TFIn("test.graph")
G4 = snap.TNGraph.Load(FIn)
print("G4: Nodes %d, Edges %d" % (G4.GetNodes(), G4.GetEdges()))
# save and load from a text file
snap.SaveEdgeList(G4, "test.txt", "Save as tab-separated list of edges")
G5 = snap.LoadEdgeList(snap.PNGraph, "test.txt", 0, 1)
print("G5: Nodes %d, Edges %d" % (G5.GetNodes(), G5.GetEdges()))
# generate a network using Forest Fire model
G6 = snap.GenForestFire(1000, 0.35, 0.35)
print("G6: Nodes %d, Edges %d" % (G6.GetNodes(), G6.GetEdges()))
# convert to undirected graph
G7 = snap.ConvertGraph(snap.PUNGraph, G6)
print("G7: Nodes %d, Edges %d" % (G7.GetNodes(), G7.GetEdges()))
# get largest weakly connected component of G
WccG = snap.GetMxWcc(G6)
# get a subgraph induced on nodes {0,1,2,3,4,5}
SubG = snap.GetSubGraph(G6, snap.TIntV.GetV(0, 1, 2, 3, 4))
# get 3-core of G
Core3 = snap.GetKCore(G6, 3)
# delete nodes of out degree 10 and in degree 5
snap.DelDegKNodes(G6, 10, 5)
print("G6a: Nodes %d, Edges %d" % (G6.GetNodes(), G6.GetEdges()))
# generate a Preferential Attachment graph on 1000 nodes and node out degree of 3
G8 = snap.GenPrefAttach(1000, 3)
print("G8: Nodes %d, Edges %d" % (G8.GetNodes(), G8.GetEdges()))
# vector of pairs of integers (size, count)
CntV = snap.TIntPrV()
# get distribution of connected components (component size, count)
snap.GetWccSzCnt(G8, CntV)
# get degree distribution pairs (degree, count)
snap.GetOutDegCnt(G8, CntV)
# vector of floats
EigV = snap.TFltV()
# get first eigenvector of graph adjacency matrix
snap.GetEigVec(G8, EigV)
# get diameter of G8
snap.GetBfsFullDiam(G8, 100)
# count the number of triads in G8, get the clustering coefficient of G8
snap.GetTriads(G8)
snap.GetClustCf(G8)
InDegV = snap.TIntPrV()
snap.GetNodeInDegV(Graph, InDegV)
for item in InDegV:
SumDeg += item.Val2()
MeanDeg = SumDeg / n
#Main Graph
print "------Original Graph-------"
#nodes
n = Graph.GetNodes()
print "Nodes:", n
#edges
print "Edges:", Graph.GetEdges()
#triads
NumTriads = snap.GetTriads(Graph, -1)
print "Number of triads: " + str(NumTriads)
#params to generate graph
print "Params to graph: Original Graph"
#avg path length
alist = list()
i = 0
for node in Graph.Nodes():
avg = 0.0
ndh = snap.TIntH()
snap.GetShortPath(Graph, node.GetId(), ndh)
for item in ndh:
avg = avg + ndh[item]
alist.append(avg / len(ndh))
print "Avg path length", float(sum(alist)) / len(alist)
#diameter
import snap
from IPython.display import Image
## Data Types
G = snap.LoadEdgeList(snap.PNGraph, "../../RepositoryData/data/cit-HepTh.txt")
## Get node degrees
CntV = snap.TIntPrV()
snap.GetOutDegCnt(G, CntV)
for p in CntV:
print("degree %d: count %d" % (p.GetVal1(), p.GetVal2()))
print(snap.GetClustCf(G)) # clustering coefficient
print(snap.GetTriads(G))# diameter
print(snap.GetBfsFullDiam(G, 10))
## Betweenness centrality
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(G, Nodes, Edges, 1.0)
# for node in Nodes:
# print("node: %d centrality: %f" % (node, Nodes[node]))
# for edge in Edges:
# print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge]))
Graph = snap.GenRndGnm(snap.PNGraph, 10, 20)
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
plot_filename = 'connected comp_' + graph_filename[:-6] + '.png'
plot_filedir = os.path.join(plotpath, plot_filename)
plt.figure()
plt.scatter(list(connected_component.keys()),
list(connected_component.values()),
s=15)
plt.xlabel("Size of Connected Components")
plt.ylabel("Number of components")
plt.title("Connected Component Distribution ({})".format(graph_filename[:-6]))
plt.savefig(plot_filedir)
# [5] Connectivity and Clustering in the Network
cluster_coeff = snap.GetClustCf(G, -1)
print("Average clustering coefficient: {}".format(round(cluster_coeff, 4)))
num_triads = snap.GetTriads(G, -1)
print("Number of triads: {}".format(num_triads))
node_id = G.GetRndNId(Rnd)
node_cluster_coeff = snap.GetNodeClustCf(G, node_id)
print("Clustering coefficient of random node {}: {}".format(
node_id, round(node_cluster_coeff, 4)))
node_id = G.GetRndNId(Rnd)
node_num_triads = snap.GetNodeTriads(G, node_id)
print("Number of triads random node {} participates: {}".format(
node_id, node_num_triads))
triad_edge = snap.GetTriadEdges(G)
print("Number of edges that participate in at least one triad: {}".format(
triad_edge))
for item in InDegV:
SumDeg += item.Val2()
MeanDeg = SumDeg / n
BAGraph = snap.LoadEdgeList(snap.PUNGraph, 'imdb_actor_ba.elist.txt', 0, 1)
#BA Graph
print ""
print "------BA Graph-------"
#nodes
n = BAGraph.GetNodes()
print "Nodes:", n
#edges
print "Edges:", BAGraph.GetEdges()
#triads
NumTriads = snap.GetTriads(BAGraph, -1)
print "Number of triads: " + str(NumTriads)
#params to generate graph
print "Params to graph: Mean node degree k", MeanDeg
#avg path length
alist = list()
i = 0
for node in BAGraph.Nodes():
avg = 0.0
ndh = snap.TIntH()
snap.GetShortPath(BAGraph, node.GetId(), ndh)
for item in ndh:
avg = avg + ndh[item]
alist.append(avg / len(ndh))
print "Avg path length", float(sum(alist)) / len(alist)
print("Approximate effective diameter by sampling 1000 nodes: %.4f" %
dEff_1000)
print("Approximate effective diameter (mean and variance): %.4f, %.4f" %
(m_dEff, v_dEff))
print("Fraction of nodes in largest connected component: %.4f" %
snap.GetMxSccSz(G))
EdgeV = snap.TIntPrV()
snap.GetEdgeBridges(G, EdgeV)
print("Number of edge bridges:", len(EdgeV))
ArtNIdV = snap.TIntV()
snap.GetArtPoints(G, ArtNIdV)
print("Number of articulation points:", len(ArtNIdV))
print("Average clustering coefficient: %.4f" % snap.GetClustCf(G, -1))
print("Number of triads:", snap.GetTriads(G, -1))
Ran_n = G.GetRndNId(Rnd)
print("Clustering coefficient of random node %d: %.4f" %
(Ran_n, snap.GetNodeClustCf(G, Ran_n)))
Ran_n = G.GetRndNId(Rnd)
print("Number of triads random node %d participates: %d" %
(Ran_n, snap.GetNodeTriads(G, Ran_n)))
print("Number of edges that participate in at least one triad:",
snap.GetTriadEdges(G))
snap.PlotInDegDistr(G, "D_" + sys.argv[1], "Degree Distribution")
MoveFile(os.path.join(dirname, "inDeg.D_" + sys.argv[1] + ".png"),
os.path.join(dirname, "plots", "deg_dist_" + sys.argv[1] + ".png"))
snap.PlotShortPathDistr(G, "S_" + sys.argv[1], "Shortest path Distribution")
MoveFile(
def triads(graph):
"""Get number of closed and open triads in graph"""
closed, _, open = snap.GetTriadsAll(graph)
return snap.GetTriads(graph), closed, open
import snap
import sys
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
#loading steam-sweden dataset
Graph = snap.LoadEdgeList(snap.PUNGraph, "Steam-Sweden.txt", 0, 1)
#calculating number of triads with random sampling
NumTriads = snap.GetTriads(Graph, -1)
print "Number of triads: " + str(NumTriads)
#selecting random node
rm_node = Graph.GetRndNId()
#random node clustering coefficient
rm_clus_coeff = snap.GetNodeClustCf(Graph, rm_node)
print "Clustering coefficient of random node ", rm_node, " in Steam-Sweden: ", rm_clus_coeff
#Number of triads a randomly selected node participates in
num_triads = snap.GetNodeTriads(Graph, rm_node)
print "Number of triads of node ", rm_node, " participates in ", num_triads, " triads"
#avg and global clustering coefficient
TriadV = snap.TIntTrV()
snap.GetTriads(Graph, TriadV, -1)
OpenTriads = 0
round(snap.GetClustCf(cit_heph_subgraph, -1), 4))
if (sub_graph_name == "email-Enron-subgraph"):
#Compute Average Clustering coeffiecient
print "Average Clustering coeffiecient in email-Enron-subgraph :" + str(
round(snap.GetClustCf(email_enron_subgraph, -1), 4))
if (sub_graph_name == "p2p-Gnutella04-subgraph"):
#Compute Average Clustering coeffiecient
print "Average Clustering coeffiecient in p2p-Gnutella04-subgraph :" + str(
round(snap.GetClustCf(p2p_gnutella04_subgraph, -1), 4))
# Task 1.2.5.2
if (sub_graph_name == "soc-Epinions1-subgraph"):
# Computing no of Triads
print "Number of Triads in soc-Epinions1-subgraph :" + str(
snap.GetTriads(soc_epinions1_subgraph, -1))
if (sub_graph_name == "cit-HepPh-subgraph"):
# Computing no of Triads
print "Number of Triads in cit-HepPh-subgraph :" + str(
snap.GetTriads(cit_heph_subgraph, -1))
if (sub_graph_name == "email-Enron-subgraph"):
# Computing no of Triads
print "Number of Triads in email-Enron-subgraph :" + str(
snap.GetTriads(email_enron_subgraph, -1))
if (sub_graph_name == "p2p-Gnutella04-subgraph"):
# Computing no of Triads
print "Number of Triads in p2p-Gnutella04-subgraph :" + str(
snap.GetTriads(p2p_gnutella04_subgraph, -1))
# Task 1.2.5.3
snap.PlotShortPathDistr(graph, "temp", "Undirected graph - shortest path")
os.system("mv diam.temp.png plots/shortest_path_" + subgraph_name + ".png")
os.system("rm diam.*")
print("Fraction of nodes in largest connected component:",
round(snap.GetMxSccSz(graph), 4))
print("Number of edge bridges:", get_bridges(graph).Len())
print("Number of articulation points:",
get_articulation_points(graph).Len())
snap.PlotSccDistr(graph, "temp", "Undirected graph - scc distribution")
os.system("mv scc.temp.png plots/connected_comp_" + subgraph_name + ".png")
os.system("rm scc.*")
print("Average clustering coefficient:", round(snap.GetClustCf(graph), 4))
print("Number of triads:", snap.GetTriads(graph))
random_node = graph.GetRndNId()
print("Clustering coefficient of random node", random_node, ":",
round(get_each_nodes_ClusteringCofficient(graph)[random_node], 4))
random_node = graph.GetRndNId()
print("Number of triads random node", random_node, "participates:",
snap.GetNodeTriads(graph, random_node))
print("Number of edges that participate in at least one triad:",
snap.GetTriadEdges(graph))
snap.PlotClustCf(graph, "temp",
"Undirected graph - clustering coefficient")
os.system("mv ccf.temp.png plots/clustering_coeff_" + subgraph_name +
".png")
os.system("rm ccf.*")
ERGraph = snap.LoadEdgeList(snap.PUNGraph,'imdb_actor_er.elist.txt', 0, 1) n = Graph.GetNodes() p = float(Graph.GetEdges())/(n*(n-1)/2) #ER Graph print "" print "------ER Graph-------" #nodes n = ERGraph.GetNodes() print "Nodes:",n #edges print "Edges:",ERGraph.GetEdges() #triads NumTriads = snap.GetTriads(ERGraph,-1) print "Number of triads: "+str(NumTriads) #params to generate graph print "Params to graph: probability p = ",p #avg path length alist = list() i=0 for node in ERGraph.Nodes(): avg = 0.0 ndh = snap.TIntH() snap.GetShortPath(ERGraph,node.GetId(),ndh) for item in ndh: avg = avg + ndh[item] alist.append(avg/len(ndh)) print "Avg path length",float(sum(alist))/len(alist)
edge_bridges = V_edges.Len()
print("Number of edge bridges: ", edge_bridges)
Art_points = snap.TIntV()
snap.GetArtPoints(Graph1, Art_points)
art = Art_points.Len()
print("Number of articulation points: ", art)
str2 = "connected_comp_" + file_name
snap.PlotSccDistr(Graph1, str2,
"Distribution of sizes of connected components")
#5.Connectivity and clustering in the network
avg_cc = snap.GetClustCf(Graph1, -1)
print("Average clustering coefficient: %0.4f" % avg_cc)
triads = snap.GetTriads(Graph1, -1)
print("Number of triads: ", triads)
random1 = Graph1.GetRndNId(Rnd)
node_cc = snap.GetNodeClustCf(Graph1, random1)
print("Clustering coefficient of random node %d: %0.4f" % (random1, node_cc))
random2 = Graph1.GetRndNId(Rnd)
node_triads = snap.GetNodeTriads(Graph1, random2)
print("Number of triads random node %d participates: %d" %
(random2, node_triads))
triad_edges = snap.GetTriadEdges(Graph1, -1)
print("Number of edges that participate in at least one triad: ", triad_edges)
str3 = "clustering_coeff_" + file_name
dataset['keyword']).get_feature_names()
if re.search('[0-9].....', x) == None
]
print 'Creating node and edge list'
nx_input = output_network_inputs(id_dict, pack='snap')
# pp.pprint(nx_input)
# print_break('Network Graph: NetworkX')
# G=nx.Graph()
# G.add_nodes_from(nx_input['nodes'])
# G.add_edges_from(nx_input['edges'])
# measures = { 'centrality': nx.degree_centrality(G), 'clustering': nx.clustering(G), 'triads': nx.triangles(G) }
# pp.pprint(measures)
print_break('Network Graph: SNAP')
t0 = time.time()
G = snap.TUNGraph.New()
print 'Adding Nodes'
for i in tqdm(nx_input['nodes']):
G.AddNode(i)
print 'Adding Edges'
for x in tqdm(nx_input['edges']):
G.AddEdge(x[0], x[1])
print 'Calculating measures'
centrality = [snap.GetDegreeCentr(G, n.GetId()) for n in G.Nodes()]
measures = {
'centrality': np.mean(centrality),
'clustering': snap.GetClustCf(G),
'triads': snap.GetTriads(G)
}
pp.pprint(measures)
print_break('SNAP Graph Measures Time elapsed: %s' % (time.time() - t0))
def main():
parentDir = os.getcwd()
os.chdir(parentDir + "/subgraphs")
sub_graph = snap.LoadEdgeList(snap.PUNGraph, sys.argv[1], 0, 1)
subGraphName = sys.argv[1].split(".")[0]
os.chdir(parentDir)
#### 1 ########
node_count = 0
for node in sub_graph.Nodes():
node_count = node_count + 1
printWithOutNewLine("Number of nodes:", node_count)
printWithOutNewLine("Number of edges:", snap.CntUniqBiDirEdges(sub_graph))
#### 2 ########
printWithOutNewLine("Number of nodes with degree=7:",
snap.CntDegNodes(sub_graph, 7))
rndMaxDegNId = snap.GetMxDegNId(sub_graph)
nodeDegPairs = snap.TIntPrV()
snap.GetNodeInDegV(sub_graph, nodeDegPairs)
maxDegVal = 0
for pair in nodeDegPairs:
if (pair.GetVal1() == rndMaxDegNId):
maxDegVal = pair.GetVal2()
break
maxDegNodes = []
for pair in nodeDegPairs:
if (pair.GetVal2() == maxDegVal):
maxDegNodes.append(pair.GetVal1())
print("Node id(s) with highest degree:", end=" ")
print(*maxDegNodes, sep=',')
#### 3 ########
sampledFullDiam = []
sampledFullDiam.append(snap.GetBfsFullDiam(sub_graph, 10, False))
sampledFullDiam.append(snap.GetBfsFullDiam(sub_graph, 100, False))
sampledFullDiam.append(snap.GetBfsFullDiam(sub_graph, 1000, False))
sampledFullDiamStats = []
sampledFullDiamStats.append(round(statistics.mean(sampledFullDiam), 4))
sampledFullDiamStats.append(round(statistics.variance(sampledFullDiam), 4))
printWithOutNewLine("Approximate full diameter by sampling 10 nodes:",
sampledFullDiam[0])
printWithOutNewLine("Approximate full diameter by sampling 100 nodes:",
sampledFullDiam[1])
printWithOutNewLine("Approximate full diameter by sampling 1000 nodes:",
sampledFullDiam[2])
print("Approximate full diameter (mean and variance):", end=" ")
print(*sampledFullDiamStats, sep=',')
sampledEffDiam = []
sampledEffDiam.append(round(snap.GetBfsEffDiam(sub_graph, 10, False), 4))
sampledEffDiam.append(round(snap.GetBfsEffDiam(sub_graph, 100, False), 4))
sampledEffDiam.append(round(snap.GetBfsEffDiam(sub_graph, 1000, False), 4))
sampledEffDiamStats = []
sampledEffDiamStats.append(round(statistics.mean(sampledEffDiam), 4))
sampledEffDiamStats.append(round(statistics.variance(sampledEffDiam), 4))
printWithOutNewLine("Approximate effective diameter by sampling 10 nodes:",
sampledEffDiam[0])
printWithOutNewLine(
"Approximate effective diameter by sampling 100 nodes:",
sampledEffDiam[1])
printWithOutNewLine(
"Approximate effective diameter by sampling 1000 nodes:",
sampledEffDiam[2])
print("Approximate effective diameter (mean and variance):", end=" ")
print(*sampledEffDiamStats, sep=',')
#### 4 ########
printWithOutNewLine("Fraction of nodes in largest connected component:",
round(snap.GetMxSccSz(sub_graph), 4))
bridgeEdges = snap.TIntPrV()
snap.GetEdgeBridges(sub_graph, bridgeEdges)
printWithOutNewLine("Number of edge bridges:", len(bridgeEdges))
articulationPoints = snap.TIntV()
snap.GetArtPoints(sub_graph, articulationPoints)
printWithOutNewLine("Number of articulation points:",
len(articulationPoints))
#### 5 ########
printWithOutNewLine("Average clustering coefficient:",
round(snap.GetClustCf(sub_graph, -1), 4))
printWithOutNewLine("Number of triads:", snap.GetTriads(sub_graph, -1))
randomNodeId = sub_graph.GetRndNId()
nodeIdCcfMap = snap.TIntFltH()
snap.GetNodeClustCf(sub_graph, nodeIdCcfMap)
print("Clustering coefficient of random node", end=" ")
print(randomNodeId, end=": ")
print(round(nodeIdCcfMap[randomNodeId], 4))
print("Number of triads random node", end=" ")
print(randomNodeId, end=" participates: ")
print(snap.GetNodeTriads(sub_graph, randomNodeId))
printWithOutNewLine(
"Number of edges that participate in at least one triad:",
snap.GetTriadEdges(sub_graph, -1))
#### plots ########
if not os.path.isdir('plots'):
os.makedirs('plots')
os.chdir(parentDir + "/plots")
plotsDir = os.getcwd()
snap.PlotOutDegDistr(sub_graph, subGraphName,
subGraphName + " Subgraph Degree Distribution")
snap.PlotShortPathDistr(
sub_graph, subGraphName,
subGraphName + " Subgraph Shortest Path Lengths Distribution")
snap.PlotSccDistr(
sub_graph, subGraphName,
subGraphName + " Subgraph Connected Components Size Distribution")
snap.PlotClustCf(
sub_graph, subGraphName,
subGraphName + " Subgraph Clustering Coefficient Distribution")
files = os.listdir(plotsDir)
for file in files:
if not file.endswith(".png"):
os.remove(os.path.join(plotsDir, file))
plots = os.listdir(plotsDir)
filePrefix = "filename"
for file in plots:
nameSplit = file.split(".")
if (len(nameSplit) == 2):
continue
if (nameSplit[0] == "ccf"):
filePrefix = "clustering_coeff_"
elif (nameSplit[0] == "outDeg"):
filePrefix = "deg_dist_"
elif (nameSplit[0] == "diam"):
filePrefix = "shortest_path_"
elif (nameSplit[0] == "scc"):
filePrefix = "connected_comp_"
os.rename(file, filePrefix + nameSplit[1] + "." + nameSplit[2])
os.chdir(parentDir)
import snap G = snap.LoadEdgeList(snap.PUNGraph, './data/epinion_signed.txt', 0, 1) print snap.GetTriads(G)
#b
EdgeBridgeV = snap.TIntPrV()
snap.GetEdgeBridges(fbsgel, EdgeBridgeV)
print("Number of edge bridges:", len(EdgeBridgeV))
#c
ArtNIdV = snap.TIntV()
snap.GetArtPoints(fbsgel, ArtNIdV)
print("Number of articulation points:", len(ArtNIdV))
#d Plot
snap.PlotSccDistr(fbsgel, "connected_comp_" + str(subgraph_name),
"connected_comp_" + str(subgraph_name))
#Q5
#a
print("Average clustering coefficient:", round(snap.GetClustCf(fbsgel, -1), 4))
#b
print("Number of triads:", snap.GetTriads(fbsgel, -1))
#c
RnId = fbsgel.GetRndNId(Rnd)
print("Clustering coefficient of random node " + str(RnId) + ":",
round(snap.GetNodeClustCf(fbsgel, RnId), 4))
#d
print("Number of triads random node " + str(RnId) + " participates:",
snap.GetNodeTriads(fbsgel, RnId))
#e
print("Number of edges that participate in at least one triad:",
snap.GetTriadEdges(fbsgel, -1))
#f Plot
snap.PlotClustCf(fbsgel, "clustering_coeff_" + str(subgraph_name),
"clustering_coeff_" + str(subgraph_name))
InDegV = snap.TIntPrV()
snap.GetNodeInDegV(Graph, InDegV)
for item in InDegV:
SumDeg += item.Val2()
MeanDeg = SumDeg / n
#WS Graph
print "------WS Graph-------"
#nodes
n = WSGraph.GetNodes()
print "Nodes:", n
#edges
print "Edges:", WSGraph.GetEdges()
#triads
NumTriads = snap.GetTriads(WSGraph, -1)
print "Number of triads: " + str(NumTriads)
#params to generate graph
print "Params to graph: Mean node degree k", MeanDeg
#avg path length
alist = list()
i = 0
for node in WSGraph.Nodes():
avg = 0.0
ndh = snap.TIntH()
snap.GetShortPath(WSGraph, node.GetId(), ndh)
for item in ndh:
avg = avg + ndh[item]
alist.append(avg / len(ndh))
print "Avg path length", float(sum(alist)) / len(alist)
