예제 #1
0
def benchmark_neanet(Graph):
    '''
    Perform benchmark tests for Directed Attribute Graphs
    '''

    results = {}
    results['num_nodes'] = Graph.GetNodes()
    results['num_edges'] = Graph.GetEdges()

    for degree in range(0, 11):
        num = snap.NodesGTEDegree(Graph, degree)
        percent_deg = float(num) / results['num_nodes']
        results['deg_gte_%d' % degree] = num
        results['deg_gte_%d_percent' % degree] = percent_deg

    # Check for over-weighted nodes
    results['max_degree'] = snap.MxDegree(Graph)

    num = snap.NodesGTEDegree(Graph, results['max_degree'])
    results['max_degree_num'] = num

    results['max_wcc_percent'] = snap.GetMxWccSz(Graph) \
      / results['num_nodes']
    results['max_scc_percent'] = snap.GetMxSccSz(Graph).GetNodes() \
      / results['num_nodes']

    return results
예제 #2
0
def runRobustnessTestMax(graph, rounds=30):
    graph = cloneGraph(graph)
    result = []
    originalNodesCnt = graph.GetNodes()
    for i in range(rounds):
        fractionRemoved = 1.0 - float(
            graph.GetNodes()) / float(originalNodesCnt)
        result.append((fractionRemoved, snap.GetMxSccSz(graph)))
        for n in range(originalNodesCnt / rounds):
            graph.DelNode(snap.GetMxDegNId(graph))
    return result
def get_robustness(file_path, LSCC_output_path, LWCC_output_path):
    frac_list = [
        0.0001, 0.001, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9
    ]
    Graph, H = load_graph(file_path)
    InDegV = snap.TIntPrV()
    snap.GetNodeInDegV(Graph, InDegV)
    OutDegV = snap.TIntPrV()
    snap.GetNodeOutDegV(Graph, OutDegV)
    degree = dict()
    for item in InDegV:
        ID = item.GetVal1()
        InDeg = item.GetVal2()
        degree[ID] = InDeg
    for item in OutDegV:
        ID = item.GetVal1()
        OutDeg = item.GetVal2()
        degree[ID] += OutDeg
    sorted_degree = sorted(degree.items(), key=itemgetter(1), reverse=True)
    tot = len(sorted_degree)
    pos = [int(tot * frac) for frac in frac_list]
    print pos
    cur = 0
    LSCC_robust = list()
    LWCC_robust = list()
    for i in range(tot):
        Graph.DelNode(sorted_degree[i][0])
        if i == pos[cur] - 1:
            LSCC_frac = snap.GetMxSccSz(Graph)
            LWCC_frac = snap.GetMxWccSz(Graph)
            singleton_frac = 1.0 - 1.0 * snap.CntNonZNodes(
                Graph) / Graph.GetNodes()
            LSCC_robust.append({
                'removed': frac_list[cur],
                'singleton': singleton_frac,
                'middle': 1.0 - singleton_frac - LSCC_frac,
                'LSCC': LSCC_frac
            })
            LWCC_robust.append({
                'removed': frac_list[cur],
                'singleton': singleton_frac,
                'middle': 1.0 - singleton_frac - LWCC_frac,
                'LWCC': LWCC_frac
            })
            cur += 1
        if cur >= len(pos):
            break
    LSCC_robust = pd.DataFrame(LSCC_robust)
    LSCC_robust = LSCC_robust[['removed', 'singleton', 'middle', 'LSCC']]
    LSCC_robust.to_csv(LSCC_output_path, index=False, encoding='utf-8')
    LWCC_robust = pd.DataFrame(LWCC_robust)
    LWCC_robust = LWCC_robust[['removed', 'singleton', 'middle', 'LWCC']]
    LWCC_robust.to_csv(LWCC_output_path, index=False, encoding='utf-8')
예제 #4
0
def runRobustnessTestRandomly(graph, rounds=30):
    graph = cloneGraph(graph)
    result = []
    rnd = snap.TRnd()
    rnd.Randomize()
    originalEdgesCnt = graph.GetEdges()
    for i in range(rounds):
        fractionRemoved = 1.0 - float(
            graph.GetEdges()) / float(originalEdgesCnt)
        result.append((fractionRemoved, snap.GetMxSccSz(graph)))
        for n in range(originalEdgesCnt / rounds):
            graph.DelEdge(graph.GetRndEId(rnd))
    return result
예제 #5
0
    def genGraphInfo(self):
        graphName = self.graphName

        # get the number of nodes and edges in the graph
        print "Number of nodes in %s: %d" % (graphName, self.G.GetNodes())
        print "Number of edges in %s: %d" % (graphName, self.G.GetEdges())

        # get the node id(s) with highest degree

        nodeIdMaxDegree = snap.GetMxOutDegNId(self.G)

        maxDegree = -1
        for node in self.G.Nodes():
            if (node.GetId() == nodeIdMaxDegree):
                maxDegree = node.GetOutDeg()
                break

        nodeIdsMaxDegreeT = ""
        for node in self.G.Nodes():
            if (maxDegree == node.GetOutDeg()):
                nodeIdsMaxDegreeT += str(node.GetId()) + ","

        print "Node id(s) with highest degree in %s: %s" % (graphName,
                                                            nodeIdsMaxDegreeT)

        # plot degree distribution
        snap.PlotOutDegDistr(self.G, graphName, "Degree Distribution")
        degreeFileName = "outDeg." + graphName + ".png"
        print "Degree distribution of %s is in: %s" % (graphName,
                                                       degreeFileName)

        # plot shortest path distribution
        snap.PlotShortPathDistr(self.G, graphName,
                                "Shortest Path Distribution")
        shortestPathFileName = "diam." + graphName + ".png"
        print "Shortest path distribution of %s is in: %s" % (
            graphName, shortestPathFileName)

        # get the fraction of nodes in largest cc
        print "Fraction of nodes in largest connected component in %s: %f" % (
            graphName, snap.GetMxSccSz(self.G))

        # plot the component size distribution
        snap.PlotSccDistr(self.G, graphName, "Component size distribution")
        sccFileName = "scc." + graphName + ".png"
        print "Component size distribution of %s is in: %s" % (graphName,
                                                               sccFileName)
def wikiVotingNetwork():

    Component = snap.TIntPrV()
    #Loding the graph
    Wiki = snap.LoadEdgeList(snap.PNGraph, "Wiki-Vote.txt", 0, 1)
    #Printing Number of Nodes in the Graph
    print "Number of Nodes: ", Wiki.GetNodes()
    #Printing Number of Edges in the Graph
    print "Number of Edges: ", Wiki.GetEdges()
    #Printing Number of Directed Edges in the Graph
    print "Number of Directed Edges: ", snap.CntUniqDirEdges(Wiki)
    #Printing Number of Un-Directed Edges in the Graph
    print "Number of Undirected Edges: ", snap.CntUniqUndirEdges(Wiki)
    #Printing Number of Directed Edges in the Graph
    print "Number of Self-Edges: ", snap.CntSelfEdges(Wiki)
    #Printing Number of Zero InDeg Nodes in the Graph
    print "Number of Zero InDeg Nodes: ", snap.CntInDegNodes(Wiki, 0)
    #Printing Number of Zero OutDeg Nodes in the Graph
    print "Number of Zero OutDeg Nodes: ", snap.CntOutDegNodes(Wiki, 0)
    #Printing Node ID with maximum degree in the Graph
    print "Node ID with maximum degree: ", snap.GetMxDegNId(Wiki)

    snap.GetSccSzCnt(Wiki, Component)

    for comp in Component:
        #printing number of strongly connected components with size
        print "Size: %d - Number of Strongly Connected Components: %d" % (
            comp.GetVal1(), comp.GetVal2())
    #printing size of largest connected components
    print "Size of largest connected component: ", snap.GetMxSccSz(Wiki)

    snap.GetWccSzCnt(Wiki, Component)

    for comp in Component:
        #printing number of weekly connected components with size
        print "Size: %d - Number of Weekly Connected Component Wikipedia: %d" % (
            comp.GetVal1(), comp.GetVal2())

    #printing size of weekly connected components
    print "Size of Weakly connected component: ", snap.GetMxWccSz(Wiki)
    #plotting out-degree distribution
    snap.PlotOutDegDistr(Wiki, "wiki-analysis",
                         "Directed graph - Out-Degree Distribution")
예제 #7
0
def analyze(graph):

    n = graph.GetNodes()
    m = graph.GetEdges()

    maxSCCsize = snap.GetMxSccSz(graph)
    maxWCCsize = snap.GetMxWccSz(graph)
    avgDegree = (m * float(2)) / n

    # estimate power law exponent
    degs = []
    degCounts = []
    DegToCntV = snap.TIntPrV()
    snap.GetDegCnt(graph, DegToCntV)
    for item in DegToCntV:
        degs.append(item.GetVal1())
        degCounts.append(item.GetVal2())
    xMin = min(degs) - 0.5
    m = graph.GetNodes()
    alphaMLLE = 1 + (m / (sum([np.log(i / xMin) * degCounts[degs.index(i)] for i in degs])))

    # erdos-renyi clustering coefficient
    graphER = snap.GenRndGnm(snap.PUNGraph, n, m)
    avgClustCoeffER = snap.GetClustCf(graphER, -1)

    # average shortest path
    graphWCC = snap.GetMxWcc(graph)
    avgClustCoeff = snap.GetClustCf(graphWCC, -1)
    numSamples = min(graphWCC.GetNodes(), 617) # all nodes or sample size
    Rnd = snap.TRnd(42)
    Rnd.Randomize()
    shortPathList = []
    for i in xrange(numSamples):
        s = graphWCC.GetRndNId(Rnd)
        NIdToDistH = snap.TIntH()
        snap.GetShortPath(graphWCC, s, NIdToDistH)
        for item in NIdToDistH:
            shortPathList.append(NIdToDistH[item])
    avgShortPath = np.mean(shortPathList)

    return avgClustCoeff, maxSCCsize, maxWCCsize, avgDegree, alphaMLLE, avgClustCoeffER, avgShortPath
예제 #8
0
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)
예제 #9
0
def q2_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:
    outward_set = set()
    BfsTree = snap.GetBfsTree(G, 2018, True, False)
    for EI in BfsTree.Edges():
        outward_set.add(EI.GetDstNId())
        # print "Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())
    inward_set = set()
    BfsTree = snap.GetBfsTree(G, 2018, False, True)
    for EI in BfsTree.Edges():
        inward_set.add(EI.GetDstNId())
        # print "Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())
    print('inward_set', len(inward_set))
    print('outward_set', len(outward_set))
    print('G size', G.GetEdges())
    MxScc = snap.GetMxScc(G)
    mxSccSize = MxScc.GetNodes()
    print 'SCC size:', mxSccSize
    print 'Relative size of SCC in Directed Graph:', snap.GetMxSccSz(G)
    
    
    ##########################################################################
    
    ##########################################################################
    #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:
        #Your code here:
    outward_set = set()
    BfsTree = snap.GetBfsTree(G, 224, True, False)
    for EI in BfsTree.Edges():
        outward_set.add(EI.GetDstNId())
        # print "Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())
    inward_set = set()
    BfsTree = snap.GetBfsTree(G, 224, False, True)
    for EI in BfsTree.Edges():
        inward_set.add(EI.GetDstNId())
        # print "Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())
    print('inward_set', len(inward_set))
    print('outward_set', len(outward_set))
    print('G size', G.GetEdges())
    print 'Relative size of SCC in Directed Graph:', snap.GetMxSccSz(G)
    
    
    
    
    
    ##########################################################################

    print '2.1: Done!\n'
예제 #10
0
G = snap.LoadEdgeList(snap.PNGraph, "Wiki-Vote.txt", 0, 1)
snap.PrintInfo(G, "votes Stats", "votes-info.txt", False)

# Node ID with maximum degree
NId1 = snap.GetMxDegNId(G)
print("Node ID with Maximum-Degree: %d" % NId1)

# Number of Strongly connected components
ComponentDist = snap.TIntPrV()
snap.GetSccSzCnt(G, ComponentDist)
for comp in ComponentDist:
    print("Size: %d - Number of Components: %d" %
          (comp.GetVal1(), comp.GetVal2()))

# Size of largest strongly connected component
print("Strongly Connected Component - Maximum size:", snap.GetMxSccSz(G))

# Number of Weakly Connected Components
CompDist = snap.TIntPrV()
snap.GetWccSzCnt(G, CompDist)
for comp in CompDist:
    print("Size: %d - Number of Components: %d" %
          (comp.GetVal1(), comp.GetVal2()))

# Size of largest weakly connected component
print("Weakly Connected Component - Maximum size:", snap.GetMxWccSz(G))

# Plot of Outdegree Distribution
snap.PlotOutDegDistr(G, "Wiki Votes", "Wiki-Votes Out Degree")
예제 #11
0
    plt.ylabel("Cumulative PageRank")

    #get node in-degree distribution
    plt.figure()
    for graph in graphs:
        y = sorted([float(node.GetInDeg())/node.GetDeg() for node in graph.Nodes()])
        #y = [float(val-min(y))/(max(y)-min(y)) for val in y]
        x = [float(i+1)/graph.GetNodes() for i in range(len(y))]
        plt.plot(x,y, '.', markersize=4)
        plt.title("Node Distribution by Win Percentage")
        plt.legend(names)
        plt.xlabel("Node Fraction")
        plt.ylabel("Win Percentage")

    Rnd = snap.TRnd(42)
    Rnd.Randomize()

    min_edges_per_node = min([float(graph.GetEdges())/graph.GetNodes() for graph in graphs])

    for graph in graphs:
        while float(graph.GetEdges())/graph.GetNodes() > min_edges_per_node:
            graph.DelEdge(graph.GetRndEId(Rnd))

    print 'names:', names
    print 'nodes:', [graph.GetNodes() for graph in graphs]
    print 'edges:', [graph.GetEdges() for graph in graphs]
    print 'mxscc:', [snap.GetMxSccSz(graph) for graph in graphs]
    print 'max degree:', [graph.GetNI(snap.GetMxDegNId(graph)).GetDeg() for graph in graphs]

    plt.show()
      " nodes: %0.4f" % eff1)
print("Approximate effective diameter by sampling ", 100,
      " nodes: %0.4f" % eff2)
print("Approximate effective diameter by sampling ", 1000,
      " nodes: %0.4f" % eff3)
effmean = (eff1 + eff2 + eff3) / 3.0
effvar = (((eff1 * eff1) + (eff2 * eff2) +
           (eff3 * eff3)) / 3.0) - (effmean * effmean)
print("Approximate effective diameter (mean and variance): %0.4f,%0.4f" %
      (effmean, effvar))

str1 = 'shortest_path_' + file_name
snap.PlotShortPathDistr(Graph1, str1, "Distribution of shortest path lengths")

#4.Components of the network
fraction = snap.GetMxSccSz(Graph1)
print("Fraction of nodes in largest connected component: %0.4f" % fraction)

V_edges = snap.TIntPrV()
snap.GetEdgeBridges(Graph1, V_edges)
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")
예제 #13
0
print("Approximate full diameter (mean and variance): %.4f, %.4f" %
      (m_dFull, v_dFull))

dEff_10 = snap.GetBfsEffDiam(G, 10, False)
dEff_100 = snap.GetBfsEffDiam(G, 100, False)
dEff_1000 = snap.GetBfsEffDiam(G, 1000, False)
m_dEff, v_dEff = map(float, MeanAndVariance(dEff_10, dEff_100, dEff_1000))
print("Approximate effective diameter by sampling 10 nodes: %.4f" % dEff_10)
print("Approximate effective diameter by sampling 100 nodes: %.4f" % dEff_100)
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)))
예제 #14
0
em = mean(effData)
ev = variance(effData)

print "Approx. effective diameter in %s with sampling 10 nodes: %d" % (
    file, effDiam10)
print "Approx. effective diameter in %s with sampling 100 nodes: %d" % (
    file, effDiam100)
print "Approx. effective diameter in %s with sampling 1000 nodes: %d" % (
    file, effDiam1000)
print "Approx. effective diameter in %s (mean and variance): %d, %d\n" % (
    file, em, ev)
# c) Plot of the distribution of the shortest path
plotFN1 = file + ".diam.short-path-plot.png"
snap.PlotShortPathDistr(UGraph, plotFN1,
                        "Undirected graph - Shortest path for file " + file)
print "\nShortest path distribution of %s is in: %s\n" % (file, plotFN1)

# 4) Components of the network:
print "Components of the network:\n"
# a) Fraction of nodes in the largest connected component
nodeFrac = snap.GetMxSccSz(UGraph)
print "Fraction of nodes in largest connected component in '%s': %d\n" % (
    file, nodeFrac)
# b) Plot of the distribution of sizes of connected components.
plotFN2 = file + ".scc.connected-components-plot.png"
snap.PlotSccDistr(UGraph, plotFN2,
                  "Undirected graph - scc distribution for file " + file)
print "\nComponent size distribution of %s is in: %s\n" % (file, plotFN2)

# end of program
print "\n\t End of program\n\n"
예제 #15
0
def graphStructure(elistName, elistPath):
    """
        Calculate properties of the graph as given in the assignment

        Args:
        elistName (str) -> Input elist name
        elistPath (pathlib.Path) -> Input elist using which graph needs to be built

        Return:
        RESULTS (dict) -> Dictionary containing results for different subparts of the assignment
    """

    RESULTS = {}
    subGraph = snap.LoadEdgeList(snap.PUNGraph, elistPath, 0, 1)

    # Part 1 (Size of the network)
    RESULTS['nodeCount'] = subGraph.GetNodes()
    RESULTS['edgeCount'] = subGraph.GetEdges()

    # Part 2 (Degree of nodes in the network)
    maxDegree = 0
    maxDegreeNodes = []
    degree7Count = 0

    for node in subGraph.Nodes():
        if node.GetDeg() == 7:
            degree7Count += 1

        maxDegree = max(maxDegree, node.GetDeg())

    for node in subGraph.Nodes():
        if node.GetDeg() == maxDegree:
            maxDegreeNodes.append(node.GetId())

    plotFilename = f"deg_dist_{elistName}"
    # Since it is an undirected graph, in/out degree is unimportant
    snap.PlotOutDegDistr(subGraph, plotFilename)

    RESULTS['maxDegree'] = maxDegree
    RESULTS['maxDegreeNodes'] = ','.join(map(str, maxDegreeNodes))
    RESULTS['degree7Count'] = degree7Count

    # Part 3 (Paths in the network)
    # Full Diameter Calculation
    fullDiameters = {
        10: snap.GetBfsFullDiam(subGraph, 10, False),
        100: snap.GetBfsFullDiam(subGraph, 100, False),
        1000: snap.GetBfsFullDiam(subGraph, 1000, False)
    }
    fullMean, fullVariance = meanVariance(fullDiameters.values())
    fullDiameters['mean'] = fullMean
    fullDiameters['variance'] = fullVariance
    RESULTS['fullDiameters'] = fullDiameters

    # Effective Diameter Calculation
    effDiameters = {
        10: snap.GetBfsEffDiam(subGraph, 10, False),
        100: snap.GetBfsEffDiam(subGraph, 100, False),
        1000: snap.GetBfsEffDiam(subGraph, 1000, False),
    }
    effMean, effVariance = meanVariance(effDiameters.values())
    effDiameters['mean'] = effMean
    effDiameters['variance'] = effVariance
    RESULTS['effDiameters'] = effDiameters

    plotFilename = f"shortest_path_{elistName}"
    snap.PlotShortPathDistr(subGraph, plotFilename)

    # Part 4 (Components of the network)
    edgeBridges = snap.TIntPrV()
    articulationPoints = snap.TIntV()
    RESULTS['fractionLargestConnected'] = snap.GetMxSccSz(subGraph)
    snap.GetEdgeBridges(subGraph, edgeBridges)
    snap.GetArtPoints(subGraph, articulationPoints)
    RESULTS['edgeBridges'] = len(edgeBridges)
    RESULTS['articulationPoints'] = len(articulationPoints)

    plotFilename = f"connected_comp_{elistName}"
    snap.PlotSccDistr(subGraph, plotFilename)

    # Part 5 (Connectivity and clustering in the network)
    RESULTS['avgClusterCoefficient'] = snap.GetClustCf(subGraph, -1)
    RESULTS['triadCount'] = snap.GetTriadsAll(subGraph, -1)[0]

    nodeX = subGraph.GetRndNId(Rnd)
    nodeY = subGraph.GetRndNId(Rnd)
    RESULTS['randomClusterCoefficient'] = (nodeX,
                                           snap.GetNodeClustCf(
                                               subGraph, nodeX))
    RESULTS['randomNodeTriads'] = (nodeY, snap.GetNodeTriads(subGraph, nodeY))
    RESULTS['edgesTriads'] = snap.GetTriadEdges(subGraph)

    plotFilename = f"clustering_coeff_{elistName}"
    snap.PlotClustCf(subGraph, plotFilename)

    return RESULTS
    effective_diameter.append(snap.GetBfsEffDiam(graph, 1000))
    print("Approximate effective diameter by sampling 1000 nodes:",
          round(effective_diameter[-1], 4))

    print("Approximate effective diameter (mean and variance):",
          round(get_mean(effective_diameter), 4),
          ',',
          round(get_variance(effective_diameter), 4),
          sep="")

    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:",
예제 #17
0
def main():
    # Number of nodes
    n = int(raw_input("Please enter the number of nodes"))
    # Probability of an edge between nodes
    p = float(
        raw_input(
            "Please enter the value of probability of an edge between nodes"))
    # Random Input of x pairs of nodes
    x = int(raw_input("Please enter the number of random, x pairs of nodes:"))
    # Empty graph and add nodes
    ERM = Empty_graph(n)

    # Add edges to the graph using personal Erdos Renyi Model
    Erdos_Renyi(ERM, p)
    # Erdos Renyi Clustering Coeffecient
    print("Clustering Coeffecient: ", clustering_coffecient(ERM))
    # Diameter
    diameter_ERM = snap.GetBfsEffDiamAll(ERM, 10, False)
    print(diameter_ERM[2])
    # Largest Strongly Connected Component
    print("Largest Strongly Connected Component - Maximum size:",
          snap.GetMxSccSz(Small_world))
    # Largest Size of Graph
    ERM_size = snap.GetMxScc(ERM).GetEdges()
    print(ERM_size)
    # Plot of Degree Distribution
    snap.PlotOutDegDistr(ERM, "ERMGraph", "ERM Degree Distribution")

    # Add Small World Network
    Small_world = Empty_graph(n)
    first_edges(Small_world)
    second_edges(Small_world)
    random_edges(Small_world, x)
    # Small World Clustering Coeffecient
    print("Clustering Coeffecient: ", clustering_coffecient(Small_world))
    # Diameter
    diameter_Small_world = snap.GetBfsEffDiamAll(Small_world, 10, False)
    print(diameter_Small_world[2])
    # Largest Strongly Connected Component
    print("Largest Strongly Connected Component - Maximum size:",
          snap.GetMxSccSz(Small_world))
    # Largest Size of Graph
    Small_world_size = snap.GetMxScc(Small_world).GetEdges()
    print(Small_world_size)
    # Plot of Degree Distribution
    snap.PlotOutDegDistr(Small_world, "SmallWorldGraph",
                         "Small World Degree Distribution")

    # Add Collaboration Network
    Collaboration_Network = snap.LoadEdgeList(snap.PUNGraph, "CA-HepTh.txt", 0,
                                              1)
    snap.DelSelfEdges(Collaboration_Network)
    snap.PrintInfo(Collaboration_Network, "Graph Statistics", "info.txt",
                   False)
    # Collaboration Network Clustering Coeffecient
    print("Clustering Coeffecient: ",
          clustering_coffecient(Collaboration_Network))
    # Diameter
    diameter_Collaboration_Network = snap.GetBfsEffDiamAll(
        Collaboration_Network, 10, False)
    print(diameter_Collaboration_Network[2])
    # Largest Strongly Connected Component
    print("Largest Strongly Connected Component - Maximum size:",
          snap.GetMxSccSz(Collaboration_Network))
    # Largest Size of Graph
    Collaboration_Network_size = snap.GetMxScc(
        Collaboration_Network).GetEdges()
    print(Collaboration_Network_size)
    # Plot of Degree Distribution
    snap.PlotOutDegDistr(Collaboration_Network, "CollaborationNetworkGraph",
                         "Collaboration Network Degree Distribution")
예제 #18
0
          round(diam, 4))
    i *= 10
    average += diam
    variance += (diam * diam)
average /= 3
variance = (variance / 3) - average * average
print("Approximate effective diameter(mean and variance): %0.4f,%0.4f" %
      (average, variance))
#c Plot
snap.PlotShortPathDistr(fbsgel, "shortest_path_" + str(subgraph_name),
                        "shortest_path_" + str(subgraph_name))

#Q4
#a
print("Fraction of nodes in largest connected component:",
      round(snap.GetMxSccSz(fbsgel), 4))
#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))
def main():

    Component = snap.TIntPrV()
    #loading the real world graph
    realWorld = snap.LoadEdgeList(snap.PUNGraph, "CA-HepTh.txt", 0, 1)
    #deleting the self-edges from the graph
    snap.DelSelfEdges(realWorld)
    #calling the function
    wikiVotingNetwork()
    #Taking number of nodes in a graph from real world network
    n = realWorld.GetNodes()
    #Generating an Undirected Graph
    G = snap.TUNGraph.New()
    #Taking number of edges in a graph from user
    e = int(raw_input('Enter the number of Random Edges : '))

    p = float(
        raw_input('Enter the Probability of Edges between Nodes from 0-1  : '))
    #Generating Number of Nodes
    for i in range(n):
        #Adding Nodes into the graph
        G.AddNode(i)
    #calling the function
    erdosRenyi(G, p)
    #Printing the Clustering
    print 'Erdos Renyi Clustering Co-efficient: ', clustCoefficient(G)

    diam = snap.GetBfsFullDiam(G, 9877, False)
    #printing the diameter
    print 'Erdos Renyi Diameter: ', diam
    #plotting the graph
    snap.PlotOutDegDistr(G, "Erdos-Renyi",
                         "Un-Directed graph - Out-Degree Distribution")

    snap.GetSccSzCnt(G, Component)

    for comp in Component:
        #printing number of strongly connected components with size
        print "Size: %d - Number of Connected Component in Erdos-Renyi: %d" % (
            comp.GetVal1(), comp.GetVal2())
    #printing fraction of nodes and edges
    print "Fraction of Nodes and Edges in Erdos Renyi: ", snap.GetMxSccSz(G)
    #Drawing a Erdos Renyi Graph
    snap.DrawGViz(G, snap.gvlDot, "erdosRenyi1.png", "Erdos Renyi")
    #calling the function
    smallWorldRandomNetwork(G, e)
    #printing the clustering coefficient
    print 'Small World Random Network Clustering Co-efficient: ', clustCoefficient(
        G)

    diam = snap.GetBfsFullDiam(G, 9877, False)
    #printing the diameter
    print 'Small World Random Network Diameter: ', diam

    snap.GetSccSzCnt(G, Component)

    for comp in Component:

        #printing number of strongly connected components with size

        print "Size: %d - Number of Connected Component in Small World: %d" % (
            comp.GetVal1(), comp.GetVal2())
    #fraction of nodes and edges in small world
    print "Fraction of Nodes and Edges in Small World: ", snap.GetMxSccSz(G)
    #plotting the graph
    snap.PlotOutDegDistr(G, "Small-World",
                         "Un-Directed graph - Out-Degree Distribution")
    #drawinf the graph
    snap.DrawGViz(G, snap.gvlDot, "smallWorld1.png",
                  "Small World Random Network")
    #calculating the clustering co-efficient
    print 'Real World Random Network Clustering Co-efficient: ', clustCoefficient(
        realWorld)

    diam = snap.GetBfsFullDiam(G, 9877, False)

    print 'Real World Random Network Diameter: ', diam

    snap.GetSccSzCnt(realWorld, Component)

    for comp in Component:
        #printing number of strongly connected components with size

        print "Size: %d - Number of Weekly Connected Component in Real World: %d" % (
            comp.GetVal1(), comp.GetVal2())
    #printing fraction of nodes and edges
    print "Fraction of Nodes and Edges in Small World: ", snap.GetMxSccSz(
        realWorld)
    #plotting the real world network graph
    snap.PlotOutDegDistr(realWorld, "real-World",
                         "Un-Directed graph - Out-Degree Distribution")
    #Drawing Real WOrld Graph
    snap.DrawGViz(realWorld, snap.gvlDot, "realWorld.png",
                  "Real World Random Network")