def plotDegDistr(G): DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) numNodes = G.GetNodes() print numNodes deg = [] nodes = [] tups = [] for item in DegToCntV: if item.GetVal1() == 0: numNodes -= item.GetVal2() continue deg.append(item.GetVal1()) nodes.append(item.GetVal2()) #float(item.GetVal2()) / float(numNodes)) tups.append((item.GetVal1(), float(item.GetVal2()))) fig = plt.figure() ax = plt.gca() G1Dots, = ax.plot(deg, [float(x) / float(numNodes) for x in nodes], 'o', c='blue', alpha=0.75, markeredgecolor='none') ax.set_yscale('log') ax.set_xscale('log') ax.set_ylabel('Proportion of Users') ax.set_xlabel('Number of Friends') plt.show()
def get_dists(G): deg_counts = [] degs = [] deg_vect = snap.TIntPrV() snap.GetDegCnt(G, deg_vect) for item in deg_vect: deg = item.GetVal1() cnt = item.GetVal2() deg_counts.append(cnt) degs.append(deg) out_deg = [] out_counts = [] cur_deg = min(degs) for deg, cnt in zip(degs, deg_counts): # while cur_deg < deg: # out_deg.append(cur_deg) # out_counts.append(0) # cur_deg += 1 out_deg.append(deg) out_counts.append(cnt) cur_deg += 1 deg_counts = np.asarray(out_counts) degs = np.asarray(out_deg) pdf = deg_counts.astype(float) / sum(deg_counts) cdf = np.cumsum(pdf) cdf = np.insert(cdf, 0, 0) ccdf = 1 - cdf return deg_counts, degs, cdf, ccdf, pdf
def saveDegreeDistribution(graph, filename): degToCntV = snap.TIntPrV() snap.GetDegCnt(graph, degToCntV) with open(filename, 'w') as f: for item in degToCntV: dist = float(item.GetVal2()) / float(graph.GetNodes()) f.write('%d\t%f\n' % (item.GetVal1(), dist))
def getGraphInfo(G): Degree = [] DegreeCount = [] CluDegree = [] Clu = [] DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) DegreeCountMax = 0 for item in DegToCntV: tempy = item.GetVal2() if tempy > DegreeCountMax: DegreeCountMax = tempy Degree.append(item.GetVal1()) DegreeCount.append(tempy) CfVec = snap.TFltPrV() Cf = snap.GetClustCf(G, CfVec, -1) for pair in CfVec: CluDegree.append(pair.GetVal1()) Clu.append(pair.GetVal2()) return DegreeCountMax,Degree,DegreeCount,CluDegree,Clu
def degreeDistribution(self): result = snap.TFltPrV() resultMap = collections.defaultdict(lambda:0) snap.GetDegCnt(self.rawGraph, result) for x in result: resultMap[int(x.GetVal1())] = int(x.GetVal2()) return resultMap
def analyzeDegrees(FNGraph): t1 = time.time() print "Started analysing network degrees: \n" DegToCntV = snap.TIntPrV() snap.GetDegCnt(FNGraph, DegToCntV) avgDeg = 0 xVec = list() yVec = list() for item in DegToCntV: avgDeg += int(item.GetVal2()) * int(item.GetVal1()) xVec.append(item.GetVal1()) yVec.append(item.GetVal2()) avgDeg = avgDeg/FNGraph.GetNodes() print "\tNetwork average degree %d" % avgDeg # plot degree distribution plt.figure(0) plt.plot(xVec, yVec, 'b-') plt.title("Degree distribution for Football network \n Average degree: %d" % avgDeg) plt.ylabel("Number of nodes") plt.xlabel("Degrees") plt.savefig('DegreeDistribution.png') print "\nFinished calculating in %.3f seconds\n" % (time.time()-t1)
def getBasicInfo(strPath, net): G = snap.LoadEdgeList(snap.PUNGraph,strPath,0,1) GraphInfo = {} GraphInfo['nodes'] = G.GetNodes() GraphInfo['edges'] = G.GetEdges() GraphInfo['zeroDegNodes'] = snap.CntDegNodes(G, 0) GraphInfo['zeroInDegNodes'] = snap.CntInDegNodes(G, 0) GraphInfo['zeroOutDegNodes'] = snap.CntOutDegNodes(G, 0) GraphInfo['nonZeroIn-OutDegNodes'] = snap.CntNonZNodes(G) GraphInfo['uniqueDirectedEdges'] = snap.CntUniqDirEdges(G) GraphInfo['uniqueUndirectedEdges'] = snap.CntUniqUndirEdges(G) GraphInfo['selfEdges'] = snap.CntSelfEdges(G) GraphInfo['biDirEdges'] = snap.CntUniqBiDirEdges(G) NTestNodes = 10 IsDir = False GraphInfo['approxFullDiameter'] = snap.GetBfsEffDiam(G, NTestNodes, IsDir) GraphInfo['90effectiveDiameter'] = snap.GetAnfEffDiam(G) DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) sumofNode = G.GetNodes() L = [item.GetVal1()*item.GetVal2() for item in DegToCntV] GraphInfo['averageDegree'] = float(sum(L))/(sumofNode) (DegreeCountMax ,Degree, DegreeCount, CluDegree, Clu) = getGraphInfo(G) # creatNet(G,net) return GraphInfo,DegreeCountMax , Degree, DegreeCount, CluDegree, Clu
def f(): snap = self.snap DegToCntV = snap.TFltPr64V() snap.GetDegCnt(self.graph, DegToCntV) ret = [] for item in DegToCntV: ret.append((item.GetVal1(), item.GetVal2())) return ret
def degree_distribution(): # Get node with max degree NId = snap.GetMxDegNId(G) print("max degree node", NId) # Get degree distribution DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) for item in DegToCntV: print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1()))
def CalculatePowerLawDistribution(graph, user): DegToCntV = snap.TIntPrV() snap.GetDegCnt(graph, DegToCntV) x = [] y = [] for item in DegToCntV: x.append(item.GetVal2()) y.append(item.GetVal1()) # print "%d nodes with degree %d" % (item.GetVal2(), item.GetVal1()) plt.plot(x, y, 'ro') plt.show()
def getDegreeToCount(G): """ get (degree, count-of-node, fraction-of-node) sequences """ N = G.GetNodes() DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) degreeV = [ e.GetVal1() for e in DegToCntV ] countV = [ e.GetVal2() for e in DegToCntV ] normCountV = [ k / float(N) for k in countV ] D = {'degreeV': degreeV, 'countV': countV, 'normCountV': normCountV} return D
def graphInfo(net): print '|V| = {}'.format(net.GetNodes()) print '|E| = {}'.format(net.GetEdges()) DegToCntV = snap.TIntPrV() snap.GetDegCnt(net, DegToCntV) overallDeg = 0 for item in DegToCntV: overallDeg = overallDeg + item.GetVal2()*item.GetVal1() print 'Average degree: {:.1f}'.format(float(overallDeg)/net.GetNodes()) print 'Graph connected: {}'.format(snap.IsConnected(net))
def getDataPointsToPlot(Graph, degType): """ return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ DegToCntV = snap.TIntPrV() if degType == "In": snap.GetInDegCnt(Graph, DegToCntV) elif degType == "Out": snap.GetOutDegCnt(Graph, DegToCntV) elif degType == "Total": snap.GetDegCnt(Graph, DegToCntV) else: raise ValueError("Invalid degree type: please use 'In', 'Out' or 'Total'.") NumNodes = Graph.GetNodes() DegToFrqV = { item.GetVal1() : float(item.GetVal2())/NumNodes for item in DegToCntV } DegToFrqV = sorted(DegToFrqV.items()) X, Y = zip(*DegToFrqV) ############################################################################ return X, Y def plot_graph(name): G = load_graph(name) print "{} graph nodes: {}".format(name, G.GetNodes()) print "{} graph edges: {}".format(name, G.GetEdges()) x_in, y_in = getDataPointsToPlot(G, 'In') plt.loglog(x_in, y_in, marker=',', color = 'y', label = 'In Degree') x_out, yout = getDataPointsToPlot(G, 'Out') plt.loglog(x_out, y_out, marker=',', color = 'r', label = 'Out Degree') x_total, y_total = getDataPointsToPlot(G, 'Total') plt.loglog(x_total, y_total, marker=',', color = 'b', label = 'Total Degree') #linestyle = 'dotted' plt.xlabel('Node Degree (log)') plt.ylabel('Proportion of Nodes with a Given Degree (log)') plt.title('Degree Distribution of In, Out, and Total degree for {} network'.format(name)) plt.legend() plt.show() if __name__ == "__main__": # Plot distribution graphs for RT, MT, RE, Social networks plot_graph("retweet") plot_graph("mention") plot_graph("reply") plot_graph("social")
def getGamma(graph): kmin = float('inf') kmax = -float('inf') out_arr = snap.TIntPrV() snap.GetDegCnt(graph, out_arr) for item in out_arr: deg = item.GetVal1() num = item.GetVal2() kmin = max(1, min(kmin, deg)) kmax = max(kmax, deg) return 1. + np.log(graph.GetNodes()) / (np.log(kmax) - np.log(kmin))
def getDataPointsToPlot(Graph): DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) totalNodes = Graph.GetNodes() X, Y = [], [] for output in DegToCntV: X.append(output.GetVal1()) Y.append(output.GetVal2() / float(totalNodes)) return X, Y
def degDist(self): # 度分布 DegToCntV = snap.TIntPrV() snap.GetDegCnt(self.SnapGraph, DegToCntV) degree = [] counts = [] for item in DegToCntV: counts.append(item.GetVal2()) degree.append(item.GetVal1()) plt.title('degree ditribution') plt.xlabel('degree') plt.ylabel('frequency') plt.plot(degree[0:50], counts[0:50]) plt.show()
def getNodeDegForPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ # TODO: Your code here! N = float(Graph.GetNodes()) DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) X, Y = zip(*[(item.GetVal1(), item.GetVal2()/N) for item in DegToCntV]) ############################################################################ return X, Y
def node_deg_count_vec(graph): """return a vector of dimension MaxDeg for undirected graph Args: graph: Return: np array [count of nodes with deg = i] """ DegToCntV = snap.TIntPrV() snap.GetDegCnt(graph, DegToCntV) counts = [(item.GetVal1(), item.GetVal2()) for item in DegToCntV] # [(deg, count) max_deg = max(x[0] for x in counts) ans = np.zeros(max_deg) for d, c in counts: ans[d - 1] = c return ans
def getDataPointsToPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ degreeDistribution = snap.TIntPrV() snap.GetDegCnt(Graph, degreeDistribution) N = float(Graph.GetNodes()) X, Y = [], [] for item in degreeDistribution: X.append(item.GetVal1()) Y.append(float(item.GetVal2()) / N) return X, Y
def getDataPointsToPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ X, Y = [], [] DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) for p in DegToCntV: X.append(p.GetVal1()) Y.append(p.GetVal2()) ############################################################################ return X, Y
def calcExpectedDegree(Graph): """ :param Graph - snap.PUNGraph object representing an undirected graph return type: float return: expected degree of Graph """ ############################################################################ # TODO: Your code here! ed = 0.0 degreeDistribution = snap.TIntPrV() snap.GetDegCnt(Graph, degreeDistribution) N = float(Graph.GetNodes()) for item in degreeDistribution: ed += float(item.GetVal1()) * float(item.GetVal2()) / N ############################################################################ return ed
def getDataPointsToPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) N = Graph.GetNodes() X, Y = [item.GetVal1() for item in DegToCntV ], [np.true_divide(item.GetVal2(), N) for item in DegToCntV] ############################################################################ return X, Y
def degreeDistribution(G): print "Nodes number: ", G.GetNodes() # 37444 print "Edges number: ", G.GetEdges() # 561119 DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) X = [] Y = [] for item in DegToCntV: X.append(item.GetVal1()) Y.append(item.GetVal2()) plt.loglog(X, Y, linestyle='dotted', color='b', label='Collaboration Network') plt.ylabel('Number of Users') plt.xlabel('Number of Neighbors (degree)') plt.show()
def form_degree_distribution(self, normalized=False): """ sets self._degree_distribution as a dict of degrees to count of nodes with that degree. :return: the histogram dict described above. """ data = snap.TIntPrV() snap.GetDegCnt(self._graph, data) histogram = {} for item in data: histogram[item.GetVal1()] = item.GetVal2() if normalized: total = sum(histogram.values()) for deg in histogram: histogram[deg] = 1.0 * shistogram[deg] / total self._degree_distribution = histogram
def getDataPointsToPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ # TODO: Your code here! X, Y = [], [] DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) for item in DegToCntV: X += [item.GetVal1()] Y += [item.GetVal2()] ############################################################################ return X, Y
def getDataPointsToPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ # TODO: Your code here! X, Y = [], [] DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) for item in DegToCntV: X.append(item.GetVal1()) #get degree Y.append(item.GetVal2()/float(Graph.GetNodes())) #get proportion of nodes with certain degree ############################################################################ return X, Y
def getDataPointsToPlot(Graph): """ :param - Graph: snap.PUNGraph object representing an undirected graph return values: X: list of degrees Y: list of frequencies: Y[i] = fraction of nodes with degree X[i] """ ############################################################################ # TODO: Your code here! N = Graph.GetNodes() DegToCntV = snap.TIntPrV() snap.GetDegCnt(Graph, DegToCntV) X, Y = [], [] for item in DegToCntV: #print "%d nodes with degree %d" % (item.GetVal2(), item.GetVal1()) X.append(item.GetVal1()) Y.append(item.GetVal2() * 1.0 / N) ############################################################################ return X, Y
def plotDegDistr(G): DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) numNodes = G.GetNodes() print numNodes deg = [] nodes = [] tups = [] for item in DegToCntV: if item.GetVal1() == 0: numNodes -= item.GetVal2() continue deg.append(item.GetVal1()) nodes.append(item.GetVal2()) #float(item.GetVal2()) / float(numNodes)) tups.append((item.GetVal1(), float(item.GetVal2()))) pdf = [] for tup in tups: pdf.append((tup[0], tup[1] / float(numNodes))) pdf.sort(key=lambda x: x[0]) print pdf[:10] alpha = mleA(deg, nodes) estPDF = getPDF(pdf[1][0], pdf[-1][0], alpha) fig = plt.figure() ax = plt.gca() G1Dots, = ax.plot(deg, [float(x) / float(numNodes) for x in nodes], 'o', c='blue', alpha=0.75, markeredgecolor='none') PDFDots, = ax.plot(range(pdf[1][0] - 1, pdf[-1][0]), estPDF, c='green', alpha=0.75, markeredgecolor='none') ax.set_yscale('log') ax.set_xscale('log') ax.set_ylabel('Proportion of Users') ax.set_xlabel('Number of Friends') plt.show()
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
def userDeg(userGraph): # Degree distribution of userGraph userNum = userGraph.GetNodes() degrees = list() counts = list() DegToCntV = snap.TIntPrV() snap.GetDegCnt(userGraph, DegToCntV) for item in DegToCntV: degrees.append(item.GetVal1()) counts.append(item.GetVal2()) # Normalize the counts counts = [value / (1.0 * userNum) for value in counts] plt.plot(degrees, counts, color="#fa8072") plt.xscale('log') plt.yscale('log') plt.title('Degree Distribution for User-User Network') plt.xlabel('degree') plt.ylabel('frequency') plt.savefig('degree-user-user.pdf') plt.close()