def fit_hyperbolic(self, g): networkit.setSeed(seed=42, useThreadId=False) degrees = networkit.centrality.DegreeCentrality(g).run().scores() with PrintBlocker(): fit = powerlaw.Fit(degrees, fit_method='Likelihood') gamma = max(fit.alpha, 2.1) n, m = g.size() degree_counts = collections.Counter(degrees) n_hyper = n + max(0, 2 * degree_counts[1] - degree_counts[2]) k = 2 * m / (n_hyper - 1) def criterium(h): with PrintBlocker(): return networkit.globals.clustering(h) goal = criterium(g) def guess_goal(t): hyper_t = networkit.generators.HyperbolicGenerator( n_hyper, k, gamma, t).generate() hyper_t = self.shrink_to_giant_component(hyper_t) return criterium(hyper_t) t, crit_diff = self.binary_search(guess_goal, goal, 0, 0.99) hyper = networkit.generators.HyperbolicGenerator(n_hyper, k, gamma, t).generate() info_map = [("n", n_hyper), ("k", k), ("gamma", gamma), ("t", t)] info = "|".join([name + "=" + str(val) for name, val in info_map]) return (info, hyper)
def testMerge(self): n1, n2 = 100, 150 p1, p2 = 0.01, 0.05 def testGraphs (Gorig, Gmerge, G1): for u in range(max(Gorig.upperNodeIdBound(), G1.upperNodeIdBound())): self.assertEqual(Gmerge.hasNode(u), Gorig.hasNode(u) or G1.hasNode(u)) Gorig.forEdges(lambda u, v, w, eid: self.assertTrue(Gmerge.hasEdge(u, v))) G1.forEdges(lambda u, v, w, eid: self.assertTrue(Gmerge.hasEdge(u, v))) def checkEdges(u, v, w, eid): if Gorig.hasNode(u) and Gorig.hasNode(v) and Gorig.hasEdge(u, v): self.assertEqual(Gorig.weight(u, v), w) else: self.assertEqual(G1.weight(u, v), w) Gmerge.forEdges(checkEdges) for seed in range(1, 4): nk.setSeed(seed, False) random.seed(seed) for directed in [True, False]: for weighted in [True, False]: Gorig = nk.generators.ErdosRenyiGenerator(n1, p1, directed).generate() G1 = nk.generators.ErdosRenyiGenerator(n2, p2, directed).generate() if weighted: Gorig = self.generateRandomWeights(Gorig) G1 = self.generateRandomWeights(G1) Gmerge = copy(Gorig) nk.graphtools.merge(Gmerge, G1) testGraphs(Gorig, Gmerge, G1)
def testToUnWeighted(self): n = 200 p = 0.2 def testGraphs(G, G1): self.assertEqual(G.numberOfNodes(), G1.numberOfNodes()) self.assertEqual(G.upperNodeIdBound(), G1.upperNodeIdBound()) self.assertEqual(G.numberOfEdges(), G1.numberOfEdges()) self.assertNotEqual(G.isWeighted(), G1.isWeighted()) self.assertEqual(G.isDirected(), G1.isDirected()) self.assertEqual(G.hasEdgeIds(), G1.hasEdgeIds()) def checkEdges(u, v, w, eid): self.assertTrue(G1.hasEdge(u, v)) if G1.isWeighted(): self.assertEqual(G1.weight(u, v), 1.0) G.forEdges(checkEdges) for seed in range(1, 4): nk.setSeed(seed, False) random.seed(seed) for directed in [True, False]: G = nk.generators.ErdosRenyiGenerator(n, p, directed).generate() G1 = nk.graphtools.toWeighted(G) testGraphs(G, G1) G = self.generateRandomWeights(G) G1 = nk.graphtools.toUnweighted(G) testGraphs(G, G1)
def fit_ba(g, fully_connected_start): random.seed(42, version=2) networkit.setSeed(seed=42, useThreadId=False) n, m = g.size() m_0 = math.ceil(m / n) ba = networkit.Graph(n) nodes = ba.nodes() edges_added = 0 if fully_connected_start: start_connections = itertools.combinations(nodes[:m_0], 2) else: # circle start_connections = ( [(nodes[m_0-1], nodes[0])] + [(nodes[i], nodes[i+1]) for i in range(m_0-1)] ) for u, v in start_connections: ba.addEdge(u, v) edges_added += 1 for i, v in list(enumerate(nodes))[m_0:]: num_new_edges = min(i, int((m-edges_added)/(n-i))) to_connect = set() while len(to_connect) < num_new_edges: num_draws = num_new_edges - len(to_connect) to_connect_draws = [ random.choice(ba.randomEdge()) for i in range(num_draws) ] to_connect |= set( u for u in to_connect_draws if not ba.hasEdge(v, u) ) for u in to_connect: ba.addEdge(u, v) edges_added += num_new_edges return ba
def fit_chung_lu_constant(g): random.seed(42, version=2) networkit.setSeed(seed=42, useThreadId=False) degrees = networkit.centrality.DegreeCentrality(g).run().scores() alpha = powerlaw_fit(degrees) k = 2 * g.numberOfEdges() / g.numberOfNodes() generator = networkit.generators.PowerlawDegreeSequence(g) # Use the same gamma as the other algorithms gamma = max(alpha, 2.1) generator.setGamma(-gamma) generator.run() generator.setMinimumFromAverageDegree(max(generator.getExpectedAverageDegree(), k)) degree_sequence = generator.run().getDegreeSequence(g.numberOfNodes()) graph = networkit.generators.ChungLuGenerator(degree_sequence).generate() make_connected(graph) info_map = [ ("n", g.numberOfNodes()), ("gamma", gamma), ("k", k) ] info = "|".join([name + "=" + str(val) for name, val in info_map]) return (info, graph)
def testDijkstraFrom(self): n = 100 p = 0.15 randNodes = [i for i in range(n)] for weighted in [False, True]: for directed in [False, True]: for seed in range(4): nk.setSeed(seed, False) random.seed(seed) random.shuffle(randNodes) G = nk.generators.ErdosRenyiGenerator(n, p, directed).generate() if weighted: G = self.generateRandomWeights(G) explored = set() def exploreNode(u, d): self.assertFalse(u in explored) self.assertGreaterEqual(d, 0) explored.add(u) def testSingleSource(source): explored.clear() nk.graph.Traversal.DijkstraFrom(G, source, exploreNode) G.forNodes(testSingleSource) for nSources in range(n): explored.clear() sources = randNodes[:nSources] nk.graph.Traversal.DijkstraFrom( G, sources, exploreNode)
def fit_hyperbolic(g): random.seed(42, version=2) networkit.setSeed(seed=42, useThreadId=False) degrees = networkit.centrality.DegreeCentrality(g).run().scores() alpha = powerlaw_fit(degrees) gamma = max(alpha, 2.1) n, m = g.size() degree_counts = collections.Counter(degrees) n_hyper = n + max(0, 2*degree_counts[1] - degree_counts[2]) k = 2 * m / (n_hyper-1) def criterium(h): #networkit.setLogLevel("WARN") val = networkit.globals.clustering(h) #networkit.setLogLevel("INFO") return val goal = criterium(g) def guess_goal(t): hyper_t = networkit.generators.HyperbolicGenerator( n_hyper, k, gamma, t).generate() make_connected(hyper_t) hyper_t = shrink_to_giant_component(hyper_t) return criterium(hyper_t) t, crit_diff = binary_search(guess_goal, goal, 0.01, 0.99) hyper = networkit.generators.HyperbolicGenerator( n_hyper, k, gamma, t).generate() make_connected(hyper) info_map = [ ("n", n_hyper), ("k", k), ("gamma", gamma), ("t", t) ] info = "|".join([name + "=" + str(val) for name, val in info_map]) return (info, hyper)
def testMaxDegree(self): n = 100 p = 0.2 edgeUpdates = 10 def computeMaxDeg(G, weighted=False, inDegree=False): nodes = [] G.forNodes(lambda u: nodes.append(u)) maxDeg = 0 def getDegree(u): if weighted: return G.weightedDegreeIn( u) if inDegree else G.weightedDegree(u) return G.degreeIn(u) if inDegree else G.degreeOut(u) for u in nodes: maxDeg = max(maxDeg, getDegree(u)) return maxDeg def doTest(G): self.assertEqual(nk.graphtools.maxDegree(G), computeMaxDeg(G, False)) self.assertEqual(nk.graphtools.maxInDegree(G), computeMaxDeg(G, False, True)) self.assertEqual(nk.graphtools.maxWeightedDegree(G), computeMaxDeg(G, True)) self.assertEqual(nk.graphtools.maxWeightedInDegree(G), computeMaxDeg(G, True, True)) for seed in range(1, 4): nk.setSeed(seed, False) for directed in [True, False]: for weighted in [True, False]: G = nk.generators.ErdosRenyiGenerator(n, p, directed).generate() if weighted: G = nk.graphtools.toWeighted(G) doTest(G) for _ in range(edgeUpdates): e = nk.graphtools.randomEdge(G) G.removeEdge(e[0], e[1]) doTest(G) for _ in range(edgeUpdates): e = nk.graphtools.randomNode( G), nk.graphtools.randomNode(G) while G.hasEdge(e[0], e[1]): e = nk.graphtools.randomNode( G), nk.graphtools.randomNode(G) G.addEdge(e[0], e[1]) doTest(G)
def testCentralityApproxSpanningEdge(self): nk.setSeed(42, False) g = nk.generators.ErdosRenyiGenerator(300, 0.1, False).generate() g.indexEdges() eps = 0.1 apx = nk.centrality.ApproxSpanningEdge(g, eps) apx.run() se = nk.centrality.SpanningEdgeCentrality(g, eps) se.runParallelApproximation() for apxScore, exactScore in zip(apx.scores(), se.scores()): self.assertLessEqual(abs(apxScore - exactScore), 2 * eps)
def testAppend(self): n1, n2 = 100, 50 p1, p2 = 0.01, 0.05 nodesToDelete = 20 def testGraphs(G, G1, G2): self.assertEqual(G.numberOfNodes(), G1.numberOfNodes() + G2.numberOfNodes()) self.assertEqual(G.numberOfEdges(), G1.numberOfEdges() + G2.numberOfEdges()) self.assertEqual(G.isDirected(), G1.isDirected()) self.assertEqual(G.isDirected(), G2.isDirected()) self.assertEqual(G.isWeighted(), G1.isWeighted()) self.assertEqual(G.isWeighted(), G2.isWeighted()) nodeMap = {} v = G1.upperNodeIdBound() for u in range(G2.upperNodeIdBound()): if G2.hasNode(u): nodeMap[u] = v v += 1 G1.forNodes(lambda u: self.assertTrue(G.hasNode(u))) G1.forEdges(lambda u, v, w, eid: self.assertTrue(G.hasEdge(u, v))) G2.forNodes(lambda u: self.assertTrue(G.hasNode(nodeMap[u]))) G2.forEdges(lambda u, v, w, eid: self.assertTrue( G.hasEdge(nodeMap[u], nodeMap[v]))) for seed in range(1, 4): nk.setSeed(seed, False) random.seed(seed) for directed in [True, False]: for weighted in [True, False]: G1 = nk.generators.ErdosRenyiGenerator( n1, p1, directed).generate() G2 = nk.generators.ErdosRenyiGenerator( n2, p2, directed).generate() if weighted: G1 = self.generateRandomWeights(G1) G2 = self.generateRandomWeights(G2) G = copy(G1) nk.graphtools.append(G, G2) testGraphs(G, G1, G2) for _ in range(nodesToDelete): G1.removeNode(nk.graphtools.randomNode(G1)) G2.removeNode(nk.graphtools.randomNode(G2)) G3 = copy(G1) nk.graphtools.append(G3, G2) testGraphs(G3, G1, G2)
def testBFSfrom(self): n = 200 p = 0.15 def doBFS(G, sources): visited = [False for _ in range(n)] sequence = [] edgeSequence = [] queue = [] for source in sources: queue.append(source) visited[source] = True while len(queue) > 0: u = queue.pop(0) sequence.append(u) for v in G.neighbors(u): if visited[v] == False: queue.append(v) visited[v] = True edgeSequence.append((u, v)) return sequence, edgeSequence randNodes = [x for x in range(n)] for seed in range(1, 4): nk.setSeed(seed, False) random.seed(seed) random.shuffle(randNodes) for directed in [False, True]: G = nk.generators.ErdosRenyiGenerator(n, p, directed).generate() for i in range(1, n + 1): sources = randNodes[:i] sequence, _ = doBFS(G, sources) result = [] nk.graph.Traversal.BFSfrom(G, sources, lambda u, d: result.append(u)) self.assertListEqual(sequence, result) sources = randNodes[i - 1] _, edgeSequence = doBFS(G, [sources]) result = [] nk.graph.Traversal.BFSEdgesFrom( G, sources, lambda u, v, w, eid: result.append((u, v))) self.assertListEqual(edgeSequence, result)
def fit_er(g): random.seed(42, version=2) networkit.setSeed(seed=42, useThreadId=False) n, m = g.size() p = ((2*m)/(n-1)-2)/(n-2) graph = networkit.generators.ErdosRenyiGenerator(n, p).generate() tree_edges = random_tree(n) for u, v in tree_edges: if not graph.hasEdge(graph.nodes()[u], graph.nodes()[v]): graph.addEdge(graph.nodes()[u], graph.nodes()[v]) return graph
def analyze(self, g): # networkit.engineering.setNumberOfThreads(1) originally_weighted = g.isWeighted() if originally_weighted: g = g.toUnweighted() g.removeSelfLoops() g = self.shrink_to_giant_component(g) degrees = networkit.centrality.DegreeCentrality(g).run().scores() with PrintBlocker(): fit = powerlaw.Fit(degrees, fit_method='Likelihood') stats = { "Originally Weighted": originally_weighted, "Degree Distribution": { "Powerlaw": { "Alpha": fit.alpha, "KS Distance": fit.power_law.KS() } } } ############# # possible profiles: minimal, default, complete networkit.profiling.Profile.setParallel(1) networkit.setSeed(seed=42, useThreadId=False) pf = networkit.profiling.Profile.create(g, preset="complete") for statname in pf._Profile__measures.keys(): stats[statname] = pf.getStat(statname) stats.update(pf._Profile__properties) keys = [[key] for key in stats.keys()] output = dict() while keys: key = keys.pop() val = self.getDeepValue(stats, key) if isinstance(val, dict): keys += [key + [subkey] for subkey in val] elif isinstance(val, int) or isinstance(val, float): output[".".join(key)] = val elif key == ['Diameter Range']: output['Diameter Min'] = val[0] output['Diameter Max'] = val[1] return output
def testGraphTranspose(self): for seed in range(1, 4): nk.setSeed(seed, True) random.seed(seed) G = nk.generators.ErdosRenyiGenerator(100, 0.2, True).generate() for _ in range(20): u = nk.graphtools.randomNode(G) if not G.hasEdge(u, u): G.addEdge(u, u) # Delete a few nodes for _ in range(10): G.removeNode(nk.graphtools.randomNode(G)) self.assertGreater(G.numberOfSelfLoops(), 0) # Assign random weights GWeighted = self.generateRandomWeights(G) GWeighted.indexEdges() GTrans = nk.graphtools.transpose(GWeighted) def checkGWeightedEdges(u, v, w, eid): self.assertEqual(GWeighted.edgeId(u, v), GTrans.edgeId(v, u)) self.assertEqual(GWeighted.weight(u, v), GTrans.weight(v, u)) GWeighted.forEdges(checkGWeightedEdges) def checkGTransEdges(v, u, w, eid): self.assertEqual(GWeighted.edgeId(u, v), GTrans.edgeId(v, u)) self.assertEqual(GWeighted.weight(u, v), GTrans.weight(v, u)) GTrans.forEdges(checkGTransEdges) for u in range(GWeighted.upperNodeIdBound()): self.assertEqual(GWeighted.hasNode(u), GTrans.hasNode(u)) self.assertEqual(GWeighted.numberOfNodes(), GTrans.numberOfNodes()) self.assertEqual(GWeighted.upperNodeIdBound(), GTrans.upperNodeIdBound()) self.assertEqual(GWeighted.numberOfEdges(), GTrans.numberOfEdges()) self.assertEqual(GWeighted.upperEdgeIdBound(), GTrans.upperEdgeIdBound()) self.assertEqual(GWeighted.numberOfSelfLoops(), GTrans.numberOfSelfLoops())
def testNodeIterator(self): nk.setSeed(42, False) g = self.getSmallGraph() def doTest(g): nodes = [] g.forNodes(lambda u: nodes.append(u)) i = 0 for u in g.iterNodes(): self.assertEqual(u, nodes[i]) i += 1 doTest(g) g.removeNode(nk.graphtools.randomNode(g)) g.removeNode(nk.graphtools.randomNode(g)) doTest(g)
def ascending_recursive_PLM_orderings(g, amount_orderings): ''' Takes a graph and an amount_orderings. Returns a list of orderings based on recursive application of PLM. This list has the length amount_orderings. Reorders the leaves with a connectivity-based pseudorandom DFS. ''' if config.TIME_STAMPS >= config.TimeStamps.ALL: i = 0 before = pd.Timestamp.now() nk.setSeed(config.SEED, False) root = contraction_trees.recursive_PLM(g) orderings = ascending_connected_random_orderings(g, root, amount_orderings) if config.TIME_STAMPS >= config.TimeStamps.ALL: after = pd.Timestamp.now() print("Total time: {:f}s".format((after - before).total_seconds())) return orderings
def ascending_accumulated_contraction_orderings(g, amount_orderings): ''' Takes a graph and an amount_orderings. Returns a list of orderings. One half are plm orderings, the other affinity orderings. This list has the length amount_orderings. Reorders the leaves with a connectivity-based pseudorandom DFS. ''' if config.TIME_STAMPS >= config.TimeStamps.ALL: i = 0 before = pd.Timestamp.now() nk.setSeed(config.SEED, False) orderings = ascending_affinity_orderings( g, amount_orderings - (amount_orderings // 2)) orderings += ascending_recursive_PLM_orderings(g, amount_orderings // 2) if config.TIME_STAMPS >= config.TimeStamps.ALL: after = pd.Timestamp.now() print("Total time: {:f}s".format((after - before).total_seconds())) return orderings
def testRandomEdgesReproducibility(self): numSamples = 10 numSeeds = 3 numRepeats = 10 for directed in [False, True]: G = self.getSmallGraph(False, directed) results = [[] for i in range(numSeeds)] for repeats in range(numRepeats): for seed in range(numSeeds): nk.setSeed(seed, False) results[seed].append(nk.graphtools.randomEdges(G, numSamples)) # assert results are different for different seeds for seed in range(1, numSeeds): self.assertNotEqual(results[0][0], results[seed][0]) # assert results are consistent for same seeds for repeats in results: for x in repeats[1:]: self.assertEqual(repeats[0], x)
def testDFSfrom(self): n = 200 p = 0.15 def doDFS(G, source): visited = [False for _ in range(n)] sequence = [] edgeSequence = [] visited[source] = 1 stack = [source] while len(stack) > 0: u = stack.pop() sequence.append(u) for v in G.neighbors(u): if visited[v] == False: stack.append(v) visited[v] = True edgeSequence.append((u, v)) return sequence, edgeSequence for seed in range(1, 4): nk.setSeed(seed, False) for directed in [False, True]: G = nk.generators.ErdosRenyiGenerator(n, p, directed).generate() for source in range(n): sequence, edgeSequence = doDFS(G, source) result = [] nk.graph.Traversal.DFSfrom(G, source, lambda u: result.append(u)) self.assertListEqual(sequence, result) result = [] nk.graph.Traversal.DFSEdgesFrom( G, source, lambda u, v, w, eid: result.append((u, v))) self.assertListEqual(edgeSequence, result)
def testSCD(self): nk.setSeed(42, False) seed = 20 seeds = [seed] for name, algo in [("PageRankNibble", nk.scd.PageRankNibble(self.G, 0.1, 1e-12)), ("GCE L", nk.scd.GCE(self.G, "L")), ("GCE M", nk.scd.GCE(self.G, "M")), ("LFM", nk.scd.LFMLocal(self.G, 0.8)), ("TwoPhaseL", nk.scd.TwoPhaseL(self.G)), ("TCE", nk.scd.TCE(self.G)), ("LTE", nk.scd.LocalTightnessExpansion(self.G)), ("LocalT", nk.scd.LocalT(self.G)), ("Clique", nk.scd.CliqueDetect(self.G))]: result = algo.run(seeds)[seed] self.assertGreaterEqual(len(result), 1, "{} has empty community".format(name)) cond = nk.scd.SetConductance(self.G, result).run().getConductance() self.assertLessEqual(cond, 0.5, "{} has too large conductance".format(name))
def generate(self): networkit.setSeed(seed=time.clock(), useThreadId=False) return networkit.generators.ErdosRenyiGenerator( self.node_count, 0.0002).generate()
def generate(self): networkit.setSeed(seed=time.clock(), useThreadId=False) return networkit.generators.BarabasiAlbertGenerator( 1, self.node_count, 1).generate()
def generate(self): networkit.setSeed(seed=time.clock(), useThreadId=False) return networkit.generators.ChungLuGenerator( self.deg_sequence).generate()
def fit_er(self, g): networkit.setSeed(seed=42, useThreadId=False) return networkit.generators.ErdosRenyiGenerator.fit(g).generate()
def fit_chung_lu(g): networkit.setSeed(seed=42, useThreadId=False) return networkit.generators.ChungLuGenerator.fit(g).generate()
def fit_chung_lu(g): random.seed(42, version=2) networkit.setSeed(seed=42, useThreadId=False) g = networkit.generators.ChungLuGenerator.fit(g).generate() make_connected(g) return g