def find_partitions():
G = nx.read_edgelist('temp_graph.edges')
file = open('temp_nb_of_tanks')
for fulline in file:
# Network Components
values = fulline.split()
nb_of_tanks = int(values[0])
print(nb_of_tanks)
while len(all_partitions) < 2 ^ nb_of_tanks:
partitions = kernighan_lin_bisection(G,
partition=None,
max_iter=10,
weight='weight')
all_partitions.append(partitions[0])
all_partitions.append(partitions[1])
G_1 = nx.Graph()
G_2 = nx.Graph()
for edge in G.edges():
if edge[0] and edge[1] in partitions[0]:
G_1.add_edge(edge[0], edge[1])
elif edge[0] and edge[1] in partitions[1]:
G_2.add_edge(edge[0], edge[1])
partitions = kernighan_lin_bisection(G_1,
partition=None,
max_iter=10,
weight='weight')
all_partitions.append(partitions[0])
all_partitions.append(partitions[1])
partitions = kernighan_lin_bisection(G_2,
partition=None,
max_iter=10,
weight='weight')
all_partitions.append(partitions[0])
all_partitions.append(partitions[1])
def recursive_kl(graph: Graph, numgrp=2) -> List[Set[int]]:
"""
Recursively use Kernighan-Lin algorithm to create a k-way graph partition
"""
power = log(numgrp, 2)
if power != int(power) or power < 1:
raise ValueError("numgrp must be a power of 2 and at least 2.")
if numgrp == 2:
# Base case for recursion: use Kernighan-Lin to create 2 groups
return list(kernighan_lin_bisection(graph))
next_numgrp = numgrp / 2
groups = []
for subset in kernighan_lin_bisection(graph):
subgraph = graph.subgraph(subset)
groups.extend(recursive_kl(subgraph, numgrp=next_numgrp))
return groups
def test_multigraph():
G = nx.cycle_graph(4)
M = nx.MultiGraph(G.edges())
M.add_edges_from(G.edges())
M.remove_edge(1, 2)
A, B = kernighan_lin_bisection(M)
assert_partition_equal([A, B], [{0, 1}, {2, 3}])
def recursive_partition(G, all_partitions, levels):
if len(all_partitions) > 0 and math.log(len(all_partitions), 2) >= levels:
return all_partitions
print("nodes in original", len(G.nodes()))
partitions = kernighan_lin_bisection(G,
partition=None,
max_iter=10,
weight='weight')
pos = nx.nx_pydot.graphviz_layout(G, prog='neato')
nx.draw(G, pos, with_labels=False, node_size=10)
plt.show()
print("nb_of_partitions", len(partitions))
print("nodes in 1", len(partitions[0]))
print("nodes in 2", len(partitions[1]))
all_partitions.append(partitions[0])
all_partitions.append(partitions[1])
G_1 = nx.Graph()
G_2 = nx.Graph()
for edge in G.edges():
if edge[0] and edge[1] in partitions[0]:
G_1.add_edge(edge[0], edge[1])
else:
G_2.add_edge(edge[0], edge[1])
if (len(G_1.edges()) > 10):
all_partitions = recursive_partition(G_1,
all_partitions=all_partitions,
levels=levels)
print(len(all_partitions))
if (len(G_2.edges()) > 10):
all_partitions = recursive_partition(G_2,
all_partitions=all_partitions,
levels=levels)
print(len(all_partitions))
return all_partitions
def kl(self, G, scores=[], depth=0):
U, V = community.kernighan_lin_bisection(G)
lU = set([self.communities.get(u, 'NA') for u in U]) - {'NA'}
lV = set([self.communities.get(v, 'NA') for v in V]) - {'NA'}
shared = lU & lV
match = 0
mismatch = 0
if len(shared) > 0:
for label in shared:
mem = set(self.community(label))
ku = len(mem & U) # one side
kv = len(mem & V) # the other
mismatch += ku * kv
match += ku * ku + kv * kv
for label in lU | lV - shared: # the ones that were not split
mem = set(self.community(label))
k = len(mem)
match += k * k
agreement = match / (match + mismatch)
scores.append(agreement**(1 / (depth + 1)))
if len(lU) > 1:
scores = self.kl(G.subgraph(U), scores, depth + 1)
if len(lV) > 1:
scores = self.kl(G.subgraph(V), scores, depth + 1)
return scores
def test_multigraph():
G = nx.cycle_graph(4)
M = nx.MultiGraph(G.edges())
M.add_edges_from(G.edges())
M.remove_edge(1, 2)
for labels in permutations(range(4)):
mapping = dict(zip(M, labels))
A, B = kernighan_lin_bisection(nx.relabel_nodes(M, mapping), seed=0)
assert_partition_equal(
[A, B], [{mapping[0], mapping[1]}, {mapping[2], mapping[3]}])
def recursive_kl(graph: Graph, numgrp=2) -> List[Set[int]]:
"""
Recursively use the Kernighan-Lin algorithm to create a k-way graph partition.
This function will either return two groups or more than two depending on the
value of numgrp. Each group generated is different from the previous.
"""
power = log(numgrp, 2)
if power != int(power) or power < 1:
raise ValueError("numgrp must be a power of 2 and at least 2.")
# For a group of two bisect it and return two groups
if numgrp == 2:
# Base case for recursion: use Kernighan-Lin to create 2 groups
return list(kernighan_lin_bisection(graph))
# For the next group of two divide numgrp by 2
next_numgrp = numgrp / 2
groups = []
for subset in kernighan_lin_bisection(graph):
subgraph = graph.subgraph(subset)
groups.extend(recursive_kl(subgraph, numgrp=next_numgrp))
return groups
def get_twitter_data(filename, w=None, save=False):
'''
reads twitter data, makes bipartition and assign group memebership
with constant weights of infection
'''
f = None
DG = None
try:
f = open(filename + '.txt', 'r')
print("loaded: " + filename)
DG = nx.DiGraph()
n, m = map(int, f.readline().split())
for i, line in enumerate(f):
if i < n:
node_str = line.split()
u = int(node_str[0])
color = node_str[1]
DG.add_node(u, color=color)
else:
edges_str = line.split()
u = int(edges_str[0])
v = int(edges_str[1])
weight = float(edges_str[2])
if w is not None:
DG.add_edge(u, v, weight=w)
else:
DG.add_edge(u, v, weight=weight)
f.close()
except FileNotFoundError:
#
print(" Making graph ")
f = open('twitter/twitter_combined.txt', 'r')
DG = nx.DiGraph()
for line in f:
node_a, node_b = line.split()
DG.add_nodes_from([node_a, node_b])
DG.add_edges_from([(node_a, node_b)])
DG[node_a][node_b]['weight'] = w
print("done with edges and weights ")
G_a, G_b = community.kernighan_lin_bisection(DG.to_undirected())
for n in G_a:
DG.nodes[n]['color'] = 'red'
for n in G_b:
DG.nodes[n]['color'] = 'blue'
save_graph(filename, DG)
return DG
def create_two_clusters(G: nx.Graph):
clusters = []
partition = community.kernighan_lin_bisection(G,
None,
500,
weight='weight')
i = 0
for p in partition:
clusters.append(cluster("kernighan_lin - " + str(i), p))
i = i + 1
return clusters
def test_max_iter_argument():
G = nx.Graph([
("A", "B", {
"weight": 1
}),
("A", "C", {
"weight": 2
}),
("A", "D", {
"weight": 3
}),
("A", "E", {
"weight": 2
}),
("A", "F", {
"weight": 4
}),
("B", "C", {
"weight": 1
}),
("B", "D", {
"weight": 4
}),
("B", "E", {
"weight": 2
}),
("B", "F", {
"weight": 1
}),
("C", "D", {
"weight": 3
}),
("C", "E", {
"weight": 2
}),
("C", "F", {
"weight": 1
}),
("D", "E", {
"weight": 4
}),
("D", "F", {
"weight": 3
}),
("E", "F", {
"weight": 2
}),
])
partition = ({"A", "B", "C"}, {"D", "E", "F"})
C = kernighan_lin_bisection(G, partition, max_iter=1)
assert_partition_equal(C, ({"A", "F", "C"}, {"D", "E", "B"}))
def networkx_manipulator(graphmatrix):
#new graph object
G = nx.Graph()
#adding nodes
G.add_nodes_from([x for x in range(len(graphmatrix))])
#adding edges
for x in range(len(graphmatrix)):
for y in range(len(graphmatrix)):
if graphmatrix[x][y] == 1:
G.add_edge(x, y)
return kernighan_lin_bisection(G)
def get_community(self, k):
print("Finding communities using: {}".format(self.algorithm.upper()))
communities: Dict[str, list] = dict()
if self.algorithm.upper() == Algorithm.KERNIGHAN_LIN.value:
partitions = community.kernighan_lin_bisection(self.graph)
for p in range(len(partitions)):
communities[str(p)] = list(partitions[p])
elif self.algorithm.upper() == Algorithm.FLUIDC.value:
partitions = community.asyn_fluidc(self.graph, k, seed=10)
for p in range(k):
communities[str(p)] = list(next(partitions))
print("{} communities found".format(len(communities)))
return communities
def get_facebook_data(filename, w=None, save=False):
'''
reads twitter data, makes bipartition and assign group memebership
with constant weights of infection
'''
f = None
G = None
try:
f = open(filename + '_with_communities.txt', 'r')
print("loaded: " + filename)
G = nx.Graph()
n, m = map(int, f.readline().split())
for i, line in enumerate(f):
if i < n:
node_str = line.split()
u = int(node_str[0])
color = node_str[1]
G.add_node(u, color=color)
else:
edges_str = line.split()
u = int(edges_str[0])
v = int(edges_str[1])
weight = float(edges_str[2])
if w is not None:
G.add_edge(u, v, weight=w)
else:
G.add_edge(u, v, weight=weight)
f.close()
except FileNotFoundError:
#
print(" Making graph ")
G = facebook_circles_graph(filename, w)
G_a, G_b = community.kernighan_lin_bisection(G.to_undirected())
for n in G_a:
G.nodes[n]['color'] = 'red'
for n in G_b:
G.nodes[n]['color'] = 'blue'
save_graph(filename, G)
return G
def measgp(model, measure, *args, **kwargs):
#kwargs.setdefault('groupby','niche')
niches = model.find_data(role='niche').matrix
names = sorted(set(niches))
bioms = [
np.sum(model.results['n'][-1][niches == n])
for n in sorted(set(niches))
]
names = {n: b for n, b in zip(names, np.argsort(bioms))}
#from datatools import code_debugger
# code_debugger()
orderedniches = np.array([names[n] for n in niches])
kwargs.setdefault('groupby', orderedniches)
measure_groups(model, measure, *args, **kwargs)
measure_groups_cavity(model, measure, *args, **kwargs)
from networkx.algorithms import community
Aij = model.find_data(role='interactions').matrix.copy()
ords = []
for i in range(5):
parts = community.kernighan_lin_bisection(nx.Graph(Aij))
pbioms = [
np.sum(model.results['n'][-1][list(part)]) for part in parts
]
pnames = np.argsort(pbioms)
orderedparts = np.zeros(niches.shape)
for i, p in enumerate(parts):
orderedparts[list(p)] = pnames[i]
ords.append(orderedparts)
sbm = SBM(Aij)
measure['partition_compare'] = np.mean([
max(np.mean(ord == orderedniches),
np.mean(1 - ord == orderedniches)) for ord in ords
])
measure['SBM_compare'] = max(np.mean(sbm == orderedniches),
np.mean(1 - sbm == orderedniches))
def test_seed_argument():
G = nx.barbell_graph(3, 0)
C = kernighan_lin_bisection(G, seed=1)
assert_partition_equal(C, [{0, 1, 2}, {3, 4, 5}])
def test_defined_partition_int_nodes():
G = nx.Graph([(1, 2), (1, 3), (2, 3), (3, 4)])
partition = ({1, 2}, {3, 4})
kernighan_lin_bisection(G, partition)
def eval_bisection(graph):
"""this evaluates the main function and cach it for speed up."""
communities = list(kernighan_lin_bisection(graph))
communities.sort(key=len, reverse=True)
return communities
def test_seed_argument():
G = nx.barbell_graph(3, 0)
C = kernighan_lin_bisection(G, seed=1)
assert_partition_equal(C, [set([0, 1, 2]), set([3, 4, 5])])
def test_defined_partition_str_nodes():
G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
partition = ({"A", "B"}, {"C", "D"})
kernighan_lin_bisection(G, partition)
def test_partition_argument_non_integer_nodes():
G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
partition = ({"A", "B"}, {"C", "D"})
C = kernighan_lin_bisection(G, partition)
assert_partition_equal(C, partition)
def test_too_many_blocks():
with pytest.raises(nx.NetworkXError):
G = nx.barbell_graph(3, 0)
partition = ({0, 1}, {2}, {3, 4, 5})
kernighan_lin_bisection(G, partition)
def test_too_many_blocks():
G = nx.barbell_graph(3, 0)
partition = ({0, 1}, {2}, {3, 4, 5})
kernighan_lin_bisection(G, partition)
def test_partition():
G = nx.barbell_graph(3, 0)
C = kernighan_lin_bisection(G)
assert_partition_equal(C, [{0, 1, 2}, {3, 4, 5}])
def test_non_disjoint_partition():
G = nx.barbell_graph(3, 0)
partition = (set([0, 1, 2]), set([2, 3, 4, 5]))
kernighan_lin_bisection(G, partition)
def test_too_many_blocks():
G = nx.barbell_graph(3, 0)
partition = (set([0, 1]), set([2]), set([3, 4, 5]))
kernighan_lin_bisection(G, partition)
# -*- coding: utf-8 -*- import networkx as nx from networkx.algorithms import community G = nx.barbell_graph(5, 1) # print G.nodes # print G.edges # kernighan_lin_bisection 用于计算Kernighan-Lin二部算法的函数 res = community.kernighan_lin_bisection(G) print res # 利用渗透法在图中寻找k族群落 res = community.k_clique_communities(G, 2) print res # 使用Clauest Newman-Moore贪婪的模块化最大化在图中寻找社区 res = community.greedy_modularity_communities(G) print res
def test_non_disjoint_partition():
G = nx.barbell_graph(3, 0)
partition = ({0, 1, 2}, {2, 3, 4, 5})
kernighan_lin_bisection(G, partition)
def test_partition_argument():
G = nx.barbell_graph(3, 0)
partition = [{0, 1, 2}, {3, 4, 5}]
C = kernighan_lin_bisection(G, partition)
assert_partition_equal(C, partition)
print('Graph H: Original graph')
H = nx.read_graphml("problem1-ZacharysKarateClub.graphml")
my_module.print_graph_info(H)
my_module.draw_node_size_by_deg(H)
print('============')
# partition the network into clusters using kernighan_lin_bisection
'''
The input to the algorithm is an undirected graph G = (V,E) with vertex set V, edge set E, and (optionally)
numerical weights on the edges in E. The goal of the algorithm is to partition V into two disjoint subsets
A and B of equal (or nearly equal) size, in a way that minimizes the sum T of the weights of the subset of
edges that cross from A to B. If the graph is unweighted, then instead the goal is to minimize the number
of crossing edges; this is equivalent to assigning weight one to each edge.
'''
(set1, set2) = community.kernighan_lin_bisection(H,
partition=None,
max_iter=40,
weight='weight')
H1 = H.subgraph(set1) # create a subgraph with notes in set1
H2 = H.subgraph(set2) # create a subgraph with notes in set2
print('set1')
print(set1)
my_module.print_graph_info(H1)
my_module.draw_node_size_by_deg(H1)
print('============')
print('set2')
print(set2)
my_module.print_graph_info(H2)
my_module.draw_node_size_by_deg(H2)
def test_non_disjoint_partition():
with pytest.raises(nx.NetworkXError):
G = nx.barbell_graph(3, 0)
partition = ({0, 1, 2}, {2, 3, 4, 5})
kernighan_lin_bisection(G, partition)
