def bowtie_components(graph, name):
"""Give sizes of DISCONNECTED, IN, OUT, SCC"""
results = {}
N = graph.GetNodes()
SCC = snap.GetMxScc(graph)
n = SCC.GetRndNId()
disc = N - snap.GetMxWcc(graph).GetNodes()
scc = SCC.GetNodes()
SCC_in = snap.GetBfsTree(graph, n, False, True)
SCC_out = snap.GetBfsTree(graph, n, True, False)
in1 = SCC_in.GetNodes() - scc
out = SCC_out.GetNodes() - scc
tt = N - disc - scc - in1 - out
results["a. SCC"] = scc
results["b. IN"] = in1
results["c. OUT"] = out
results["d. TENDRILS + TUBES"] = tt
results["e. DISCONNECTED"] = disc
print 'Total nodes in {} network: {}'.format(name, N)
print 'DISCONNECTED: {}'.format(disc)
print 'SCC: {}'.format(scc)
print 'IN: {}'.format(in1)
print 'OUT: {}'.format(out)
print 'TENDRILS + TUBES: {}'.format(tt)
return results
def reachable_analysis(graph, name):
reached_out_cum = []
reached_in_cum = []
for i in range(100):
node = graph.GetRndNId()
bfs_out = snap.GetBfsTree(graph, node, True, False)
bfs_in = snap.GetBfsTree(graph, node, False, True)
reached_out_cum.append(bfs_out.GetNodes())
reached_in_cum.append(bfs_in.GetNodes())
reached_out_cum = sorted(reached_out_cum)
reached_in_cum = sorted(reached_in_cum)
y = reached_out_cum
if True:#name == 'epinions':
plt.plot(y, label='Reachability using outlinks for %s' % name)
plt.yscale('log')
#else:
# plt.plot(y, label='Reachability using outlinks for %s' % name)
plt.savefig('outlinks_%s.png' % name)
plt.close()
y = reached_in_cum
if True:#name == 'email':
plt.plot(y, label='Reachability using inlinks for %s' % name)
plt.yscale('log')
#else:
# plt.plot(y, label='Reachability using inlinks for %s' % name)
plt.savefig('inlinks_%s.png' % name)
plt.close()
def q2_1_aux(name,id):
G = load_graph(name)
# Your code here:
OutTreeEp = snap.GetBfsTree(G, id, True, False)
InTreeEp = snap.GetBfsTree(G, id, False, True)
sccOneRandNodeId = snap.GetMxScc(G).GetRndNId()
sccInOutTree = OutTreeEp.IsNode(sccOneRandNodeId)
sccInInTree = InTreeEp.IsNode(sccOneRandNodeId)
print "graph:",name
print "nodeId",id
OutTree = snap.GetBfsTree(G, id, True, False)
InTree = snap.GetBfsTree(G, id, False, True)
sizeOutTree = OutTree.GetNodes()
sizeInTree = InTree.GetNodes()
print "sizegraph", G.GetNodes()
print "sizeOutTree", sizeOutTree
print "sizeInTree", sizeInTree
if (sccInOutTree):
if (sccInInTree):
print "node in SCC"
else:
print "node in IN"
else:
print "node in OUT"
def q2_2_util(dataset_name, outward):
G = load_graph(dataset_name)
Rnd = snap.TRnd(42)
Rnd.Randomize()
rand_ids = set()
while(len(rand_ids)<100):
NId = G.GetRndNId(Rnd)
rand_ids.add(NId)
cumulative_list = []
for rand_nid in rand_ids:
if outward:
BfsTree = snap.GetBfsTree(G, rand_nid, True, False)
else:
BfsTree = snap.GetBfsTree(G, rand_nid, False, True)
outward_set = set()
for EI in BfsTree.Edges():
outward_set.add(EI.GetDstNId())
cumulative_list.append(len(outward_set))
# print(len(cumulative_list))
x = np.linspace(0, 1, 100)
# print(x)
cumulative_list.sort()
cumulative_list = np.array(cumulative_list)
# print(cumulative_list)
plt.plot(x, cumulative_list, lw=2)
plt.legend()
plt.xlabel('Frac of rand ids')
plt.ylabel('%s Reached notes (%s)' % (dataset_name, 'outward' if outward else 'inward'))
plt.yscale('log')
plt.show()
def determineLocation(Graph, nodeID):
'''
Given a nodeID, determines if it belongs to the SCC, IN, or OUT
components of the Graph using heuristics and assuming the Graph
has a BowTie structure.
Assumptions based on Experiments:
IN nodes have < 1e-4% backwards trees, > 15% forward.
OUT nodes have < 1e-4% forward trees, > 15% forward.
SCC nodes have > 15% in both directions.
All else is considered "AMBIGUOUS"
returns: Location
'''
forwardTree = snap.GetBfsTree(Graph, nodeID, True, False)
backwardTree = snap.GetBfsTree(Graph, nodeID, False, True)
N = float(Graph.GetNodes())
forward_p = forwardTree.GetNodes() / N
backward_p = backwardTree.GetNodes() / N
if forward_p > 0.15 and backward_p < 1e-4:
return Location.IN
if forward_p < 1e-4 and backward_p > 0.15:
return Location.OUT
if forward_p > 0.15 and backward_p > 0.15:
return Location.SCC
return Location.AMBIGUOUS
def q1_3_grpah(Graph):
n_nodes = Graph.GetNodes()
MxWcc = snap.GetMxWcc(Graph)
MxScc = snap.GetMxScc(Graph)
n_MxWcc = MxWcc.GetNodes()
n_MxScc = MxScc.GetNodes()
print(" TOTAL : ", n_nodes)
print(" DISCONNECTED : ", n_nodes - n_MxWcc)
print(" SCC : ", n_MxScc)
SCC_nodes = []
for NI in MxScc.Nodes():
SCC_nodes.append(NI.GetId())
num_test = 100
random_sampled_scc = random.sample(SCC_nodes, num_test)
num_out = []
num_in = []
for i in range(0, num_test):
NodeId = random_sampled_scc[i]
BfsTreeOut = snap.GetBfsTree(Graph, NodeId, True, False)
BfsTreeIn = snap.GetBfsTree(Graph, NodeId, False, True)
num_out.append(BfsTreeOut.GetNodes()) # roughly SCC + OUT
num_in.append(BfsTreeIn.GetNodes()) # roughly SCC + IN
num_out.sort()
num_in.sort()
print(" OUT : ", num_out[-1] - n_MxScc)
print(" IN : ", num_in[-1] - n_MxScc)
num_tendrils = n_MxWcc - n_MxScc - (num_out[-1] - n_MxScc) - (num_in[-1] -
n_MxScc)
print(" TENDRILS+TUBES : ", num_tendrils)
def SizeOfBowtieRegions(Graph, sccNodeID):
'''
Given a Graph with a BowTie structure as described in
http://snap.stanford.edu/class/cs224w-readings/broder00bowtie.pdf
and an sccNodeID of a node known to belong to the central SCC,
determines the size of each component.
returns: tuple of sizes (SCC, IN, OUT, TENDRILS, DISCONNECTED)
'''
totalNodes = Graph.GetNodes()
wcc = snap.GetMxWcc(Graph)
assert wcc.IsNode(sccNodeID)
wccNodes = wcc.GetNodes()
disconnectedNodes = totalNodes - wccNodes
scc = snap.GetMxScc(Graph)
# Sanity check the input.
assert scc.IsNode(sccNodeID)
sccNodes = scc.GetNodes()
sccAndOutNodes = snap.GetBfsTree(Graph, sccNodeID, True, False).GetNodes()
sccAndInNodes = snap.GetBfsTree(Graph, sccNodeID, False, True).GetNodes()
inNodes = sccAndInNodes - sccNodes
outNodes = sccAndOutNodes - sccNodes
tendrilNodes = wccNodes - (inNodes + outNodes + sccNodes)
nodes = (sccNodes, inNodes, outNodes, tendrilNodes, disconnectedNodes)
assert sum(nodes) == Graph.GetNodes()
return nodes
def q1_1():
'''
You will have to run the inward and outward BFS trees for the
respective nodes and reason about whether they are in SCC, IN or OUT.
You may find the SNAP function GetBfsTree() to be useful here.
'''
##########################################################################
#TODO: Run outward and inward BFS trees from node 2018, compare sizes
#and comment on where node 2018 lies.
G = load_graph("email")
#Your code here:
email_in = snap.GetBfsTree(G, 2018, False, True)
email_out = snap.GetBfsTree(G, 2018, True, False)
print("Total nodes of email: ", G.GetNodes())
print("IN of 2018 in email: ", email_in.GetNodes())
print("OUT of 2018 in email: ", email_out.GetNodes())
##########################################################################
##########################################################################
#TODO: Run outward and inward BFS trees from node 224, compare sizes
#and comment on where node 224 lies.
G = load_graph("epinions")
#Your code here:
ep_in = snap.GetBfsTree(G, 224, False, True)
ep_out = snap.GetBfsTree(G, 224, True, False)
print("Total nodes of epinions: ", G.GetNodes())
print("IN of 224 in epinions: ", ep_in.GetNodes())
print("OUT of 224 in epinions: ", ep_out.GetNodes())
##########################################################################
print('1.1: Done!\n')
def plot_reachablity(g, name=""):
tot_nodes = g.GetNodes()
sampled_nodes = np.random.randint(tot_nodes, size=100)
nodes_in_cnt = []
nodes_out_cnt = []
for ni in sampled_nodes:
bfs_in = snap.GetBfsTree(g, int(ni), False, True)
nodes_in_cnt.append(bfs_in.GetNodes())
bfs_out = snap.GetBfsTree(g, int(ni), True, False)
nodes_out_cnt.append(bfs_out.GetNodes())
plt.title("Reachability Using Links " + name)
plt.xlabel("Frac. of Starting Nodes")
plt.ylabel("Number of Nodes Reached")
X = np.array(range(1, 101)) / 100
Y = np.array(sorted(nodes_in_cnt))
plt.plot(X, Y, label="in link")
for (i, (x, y)) in enumerate(zip(X, Y)):
if i + 1 < 100 and Y[i + 1] - y > 1000:
plt.text(x + 0.03, y + 10, x)
Y = np.array(sorted(nodes_out_cnt))
plt.plot(X, Y, label="out link")
for (i, (x, y)) in enumerate(zip(X, Y)):
if i + 1 < 100 and Y[i + 1] - y > 1000:
plt.text(x + 0.03, y + 10, x)
plt.legend()
plt.show()
def cumul_BFS(graph, name, N=1000):
"""Get n random nodes and find the number of nodes in their inward and outward BFS trees.
Plot the cumulative number of nodes reached in the BFS runs"""
X_in, X_out = [], []
for i in range(N):
n = graph.GetRndNId()
g_out = snap.GetBfsTree(graph, n, True, False)
g_in = snap.GetBfsTree(graph, n, False, True)
X_in.append(g_in.GetNodes())
X_out.append(g_out.GetNodes())
X_in, X_out = sorted(X_in), sorted(X_out)
x = np.linspace(0.0, 1.0, N)
plt.subplot(1, 2, 1)
plt.plot(x, X_in)
plt.title('{}, using inlinks'.format(name))
plt.subplot(1, 2, 2)
plt.plot(x, X_out)
plt.title('{}, using outlinks'.format(name))
plt.savefig("../results/reachability_bfs/reachability_{}".format(name),
bbox_inches="tight")
def getbfs(G1,nodekeys,search=0,startnode=0,FollowOut=True, FollowIn=False):
bfstrees=[]
if search == 0:
bfstrees.append(snap.GetBfsTree(G1,startnode,FollowOut,FollowIn))
if search == 1:
for key in nodekeys:
bfstrees.append(snap.GetBfsTree(G1,key,FollowOut,FollowIn))
return bfstrees
def BfsDfsTest(NNodes, NEdges): Graph = snap.GenRndGnm(NNodes, NEdges, 1) snap.GetBfsTree(Graph, False, False, 1) G2 = snap.GetBfsTree(Graph, False, False, 1) return G2
def Judge(Graph, num):
G1 = snap.GetBfsTree(Graph, num, True, False)
G2 = snap.GetBfsTree(Graph, num, False, True)
forward = G1.GetNodes()
backward = G2.GetNodes()
if (forward < backward
and forward * 10 > backward) or (forward > backward
and forward < backward * 10):
return True
def GetForwardBackwardProp(Graph, nodeID):
'''
Returns the proportion of nodes visited during a forward/backward
bfs starting at nodeID
'''
forwardTree = snap.GetBfsTree(Graph, nodeID, True, False)
backwardTree = snap.GetBfsTree(Graph, nodeID, False, True)
return (float(forwardTree.GetNodes()) / Graph.GetNodes(),
float(backwardTree.GetNodes()) / Graph.GetNodes())
def findComponent(G, NId):
BfsTreeOut = snap.GetBfsTree(G, NId, True, False)
BfsTreeIn = snap.GetBfsTree(G, NId, False, True)
#print (BfsTreeOut.GetNodes(), BfsTreeIn.GetNodes())
if ((BfsTreeOut.GetNodes() < BfsTreeIn.GetNodes()) & (BfsTreeOut.GetNodes() == 1)):
print (NId, " : OUT")
elif ((BfsTreeOut.GetNodes() > BfsTreeIn.GetNodes()) & (BfsTreeIn.GetNodes() == 1)):
print (NId, " : IN")
else:
print (NId, " : SCC")
def randomStartTraversalDistribution(Graph):
'''
returns: X, Y where X[i], Y[i] are the number of reached nodes during
the forward and backward passes respectively for the i-th randomly
chosen node.
'''
X, Y = [], []
for i in xrange(NUM_NODES):
srcID = Graph.GetRndNId(Rnd)
X.append(snap.GetBfsTree(Graph, srcID, True, False).GetNodes())
Y.append(snap.GetBfsTree(Graph, srcID, False, True).GetNodes())
return X, Y
def Judge(Graph, num):
G1 = snap.GetBfsTree(Graph, num, True, False)
G2 = snap.GetBfsTree(Graph, num, False, True)
forward = G1.GetNodes()
backward = G2.GetNodes()
if (forward < backward
and forward * 5 > backward) or (forward > backward
and forward < backward * 5):
print "Node %d belongs to SCC " % (num)
elif forward > backward:
print "Node %d belongs to IN " % (num)
elif forward < backward:
print "Node %d belongs to OUT " % (num)
def getOverlapSet(self, nodeDegH):
nodeIdV = snap.TIntV()
dnodeIdV = snap.TIntV()
nodeDegH.GetKeyV(nodeIdV)
randNodeIdV=snap.TIntV()
# random choice
if self.overlap_choice == 1:
randNodeIdV=np.random.choice(nodeIdV, self.overlap_size, replace=False)
# random choice over the higher degree nodes
elif self.overlap_choice == 2:
nodeDegH_walker = nodeDegH.BegI()
counter=0
while not nodeDegH_walker.IsEnd():
if (counter>self.overlap_size*2):
break;
dnodeIdV.Add(nodeDegH_walker.GetKey())
nodeDegH_walker.Next()
randNodeIdV = np.random.choice(dnodeIdV, self.overlap_size, replace=False)
# bsf tree nodes from the highest degree node
elif self.overlap_choice == 3:
startNodeId=nodeDegH.BegI().GetKey()
BfsTree = snap.GetBfsTree(self.G, startNodeId, True, False)
for EI in BfsTree.Edges():
sourceNodeId=EI.GetSrcNId()
if(sourceNodeId not in randNodeIdV):
randNodeIdV.Add(sourceNodeId)
destNodeId = EI.GetDstNId()
if (destNodeId not in randNodeIdV):
randNodeIdV.Add(destNodeId)
if(randNodeIdV.Len()==self.overlap_size):
break;
# bsf tree nodes from random node
elif self.overlap_choice == 4:
startNodeId = np.random.choice(nodeIdV, 1, replace=False)
#print startNodeId
BfsTree = snap.GetBfsTree(self.G, startNodeId[0], True, False)
for EI in BfsTree.Edges():
sourceNodeId = EI.GetSrcNId()
#print sourceNodeId
if (sourceNodeId not in randNodeIdV):
randNodeIdV.Add(sourceNodeId)
destNodeId = EI.GetDstNId()
#print destNodeId
if (destNodeId not in randNodeIdV):
randNodeIdV.Add(destNodeId)
if (randNodeIdV.Len() == self.overlap_size):
break;
return randNodeIdV
def PlotRandomBFS(Graph, num_test=100):
Rnd = snap.TRnd(42)
Rnd.Randomize()
num_out = []
num_in = []
for i in range(0, num_test):
NodeId = Graph.GetRndNId(Rnd)
BfsTreeOut = snap.GetBfsTree(Graph, NodeId, True, False)
BfsTreeIn = snap.GetBfsTree(Graph, NodeId, False, True)
num_out.append(np.log(BfsTreeOut.GetNodes()))
num_in.append(np.log(BfsTreeIn.GetNodes()))
num_out.sort()
num_in.sort()
return num_out, num_in
def cal_con_prob(g, scc_set, In, Out):
sample_points = []
probs = []
samples = np.random.randint(g.GetNodes(), size=g.GetNodes())
connected_cnt = 0
for i in range(1, int(g.GetNodes() * 0.03)):
sample_points.append(i / g.GetNodes())
probs.append(connected_cnt / i)
# if len(probs) > 100 and abs(probs[-1] - probs[i - 100]) < 1e-6:
# break
u = samples[i << 1]
v = samples[i << 1 | 1]
if (u in scc_set or u in In) and (v in scc_set or v in Out):
connected_cnt += 1
continue
if (u in Out and (v in In or v in scc_set)) or (v in In and (u in Out or u in scc_set)):
continue
try:
g_out = snap.GetBfsTree(g, int(u), True, False)
except Exception as e:
print(e)
i -= 1
continue
for nii in g_out.Nodes():
if nii.GetId() == v:
connected_cnt += 1
break
return sample_points, probs
def q2_2_aux(name):
G = load_graph(name)
vectOut = []
vectIn = []
for i in range(100):
randInt = G.GetRndNId()
OutTreeNodesN = snap.GetBfsTree(G, randInt, True, False).GetNodes()
InTreeEpNodesN = snap.GetBfsTree(G, randInt, False, True).GetNodes()
vectIn.append(InTreeEpNodesN)
vectOut.append(OutTreeNodesN)
vectOut.sort()
vectIn.sort()
return vectIn,vectOut
def getInletRadiusPlot(G, name, filename):
"""
Run an outward BFS from each inlet and plot the size of the outset vs node "Radius"
"""
inlets = getInletIds(G)
BFS_out, x_cords = [], []
BFS_mean_rad = {}
if name == 'Healthy':
radii = util_data.loadNodeAttr(filename, small=True)
else:
radii = util_data.loadNodeAttr(filename)
for inlet in inlets:
BFS_out.append((snap.GetBfsTree(G, inlet, True,
False).GetNodes(), radii[inlet]))
for elem in BFS_out:
if elem[0] in BFS_mean_rad:
BFS_mean_rad[elem[0]].append(elem[1])
else:
BFS_mean_rad[elem[0]] = [elem[1]]
for elem in BFS_mean_rad:
BFS_mean_rad[elem] = sum(BFS_mean_rad[elem]) / len(BFS_mean_rad[elem])
# y_cords, x_cords = zip(*BFS_out)
print "Pearson Coeff for {}: {}".format(
name, pearsonr(BFS_mean_rad.values(), BFS_mean_rad.keys()))
plt.plot(BFS_mean_rad.values(), BFS_mean_rad.keys(), 'o')
plt.xlabel('Mean Radius $(\mu m)$', usetex=True)
plt.ylabel('Size of Outset')
plt.savefig("Inlet_BFS_Radius_" + name + ".pdf")
plt.clf()
def Cal(Graph, num):
Scc = 0
G1 = snap.GetBfsTree(Graph, num, True, False)
G2 = snap.GetBfsTree(Graph, num, False, True)
G3 = snap.GetBfsTree(Graph, num, True, True)
IN = G2.GetNodes()
OUT = G1.GetNodes()
print "Nodes DISCONNECTED: %d" % (Graph.GetNodes() - G3.GetNodes())
for N1 in Graph.Nodes():
if G1.IsNode(N1.GetId()) == True and G2.IsNode(N1.GetId()) == True:
Scc += 1
IN = IN - Scc
OUT = OUT - Scc
print "Nodes SCC: %d" % (Scc)
print "Nodes IN: %d" % (IN)
print "Nodes OUT: %d" % (OUT)
print "Nodes TENDRILS: %d" % (G3.GetNodes() - IN - OUT - Scc)
def q2_3_util(dataset_name):
# G = load_graph("email")
G = load_graph(dataset_name)
MxWcc = snap.GetMxWcc(G)
total_size = G.GetNodes()
wcc_size = MxWcc.GetNodes()
disconnected_size = total_size - wcc_size
print 'Total size: ', total_size
print 'WCC size: ', wcc_size
print 'DISCONNECTED: ', disconnected_size
Rnd = snap.TRnd(42)
Rnd.Randomize()
MxScc = snap.GetMxScc(G)
scc_size = MxScc.GetNodes()
number_of_trials = 1
scc_plus_out = 0
scc_plus_in = 0
out_size = 0
in_size = 0
tendrils_plus_tubes = 0
for i in xrange(number_of_trials):
NId = MxScc.GetRndNId(Rnd)
# print 'Random node id', NId
outward_set = set()
BfsTree = snap.GetBfsTree(G, NId, True, False)
for EI in BfsTree.Edges():
outward_set.add(EI.GetDstNId())
scc_plus_out = max(scc_plus_out, len(outward_set))
out_size = max( out_size, scc_plus_out - scc_size)
#
inward_set = set()
BfsTree = snap.GetBfsTree(G, NId, False, True)
for EI in BfsTree.Edges():
inward_set.add(EI.GetDstNId())
scc_plus_in = max(scc_plus_in, len(inward_set))
in_size = max(in_size, scc_plus_in - scc_size)
tendrils_plus_tubes = max(tendrils_plus_tubes, wcc_size - in_size - out_size)
print 'IN: ', in_size
print 'scc_size', scc_size
print 'scc + out: ', scc_plus_out
print 'OUT: ', out_size
print 'scc + in: ', scc_plus_in
print 'TENDRILS + TUBES', tendrils_plus_tubes
print '------------------'
def analyze_graph(G):
WCC = snap.GetMxWcc(G)
SCC = snap.GetMxScc(G)
id = SCC.GetRndNId()
out_tree = snap.GetBfsTree(G, id, True, False)
in_tree = snap.GetBfsTree(G, id, False, True)
G_size = G.GetNodes()
SCC_size = SCC.GetNodes()
WCC_size = WCC.GetNodes()
DISCONNECTED_size = G_size - WCC_size
in_size = in_tree.GetNodes() - SCC_size
out_size = out_tree.GetNodes() - SCC_size
Tendril_size = G_size - SCC_size - DISCONNECTED_size - in_size - out_size
print 'Total Graph Size: %d' % G_size
print 'SCC Size: %d' % SCC_size
print 'WCC Size: %d' % WCC_size
print 'IN Size: %d' % in_size
print 'OUT Size: %d' % out_size
print 'DISCONNECTED Size: %d' % DISCONNECTED_size
print 'Tendril tube size (remaining): %d' % Tendril_size
print()
def per_graph(graph, name):
mxWcc = snap.GetMxWcc(graph)
mxScc = snap.GetMxScc(graph)
print ''
print 'Size analysis on {}'.format(name)
print 'Disconnected size = {}'.format(graph.GetNodes() - mxWcc.GetNodes())
print 'SCC size = {}'.format(mxScc.GetNodes())
trials = 200
avg_reached_out = 0
avg_reached_in = 0
for _ in range(trials):
nodeId = mxScc.GetRndNId()
avg_reached_out += snap.GetBfsTree(graph, nodeId, True, False).GetNodes()
avg_reached_in += snap.GetBfsTree(graph, nodeId, False, True).GetNodes()
scc_out = float(avg_reached_out) / trials
scc_in = float(avg_reached_in) / trials
out_sz = scc_out - mxScc.GetNodes()
in_sz = scc_in - mxScc.GetNodes()
print 'OUT size = {}'.format(out_sz)
print 'IN size = {}'.format(in_sz)
print 'Tendrils/Tubes size = {}'.format(mxWcc.GetNodes() - mxScc.GetNodes() - out_sz - in_sz)
def get_random_subgraph_connected(G, banned_ids, subgraph_size = 300):
root = random.choice(banned_ids)
# do bfs from root, which is a banned subreddit
bfs_G = snap.GetBfsTree(G, root, True, False)
Vec_of_bfs_G_nodes = snap.TIntV()
level = [root]
# iteratively levels of BFS tree
while (len(level) > 0):
curr = level.pop(0)
if (curr not in Vec_of_bfs_G_nodes):
Vec_of_bfs_G_nodes.Add(curr)
if (Vec_of_bfs_G_nodes.Len() == subgraph_size):
break
for neigh in G.GetNI(curr).GetOutEdges():
level.append(neigh)
return snap.GetSubGraph(G, Vec_of_bfs_G_nodes)
def getInletHist(G, name):
"""
Run an outward BFS from each inlet and plot the size of the outset
"""
inlets = getInletIds(G)
BFS_out = []
for inlet in inlets:
BFS_out.append(snap.GetBfsTree(G, inlet, True, False).GetNodes())
# print len(BFS_out)
# print sorted(BFS_out, key=lambda args: args[1])
plt.hist(BFS_out)
plt.xlabel('Size of Outset')
plt.ylabel('Number of Nodes')
plt.savefig("Inlet_BFS_" + name + "_Hist.pdf")
plt.clf()
def getInletScatter(G, name):
"""
Run an outward BFS from each inlet and plot the size of the outset
"""
inlets = getInletIds(G)
BFS_out = []
for inlet in inlets:
BFS_out.append(snap.GetBfsTree(G, inlet, True, False).GetNodes())
# print len(BFS_out)
# print sorted(BFS_out, key=lambda args: args[1])
plt.scatter(*zip(*collections.Counter(BFS_out).items()))
plt.xscale('log')
plt.yscale('log')
plt.xlabel('Size of Outset')
plt.ylabel('Number of Nodes')
plt.savefig("Inlet_BFS_" + name + "_Scatter.pdf")
plt.clf()
def Plot(Graph, bool1, bool2):
nodes = set()
listy = []
listx = []
while len(nodes) < 100:
length = len(nodes)
node = Graph.GetRndNId()
nodes.add(node)
if len(nodes) - length == 0:
continue
Traverse = snap.GetBfsTree(Graph, node, bool1, bool2)
listy.append(Traverse.GetNodes())
listx.append(len(nodes) / 100)
listy.sort()
plt.figure()
plt.plot(listx, listy, marker='o', markersize=3, color="red")
plt.ylim((0.1, Graph.GetNodes()))
plt.xlim((0, 1.1))
plt.yscale('log')
plt.show()
