def edgeCut(state,partitions=2):
G = state
if type(G) is not nx.classes.graph.Graph:
G = nx.Graph()
for node in xrange(len(state.nodeList)):
G.add_node(node)
for edge in state.nodeList[node]:
G.add_edge(node,edge)
(edgecuts,parts) = metis.part_graph(G,partitions)
return edgecuts
def pre_part_graph(graph, k, df=None, verbose=False):
if verbose:
print("Begin clustering...")
clusters = 0
for i, p in enumerate(graph.nodes()):
graph.nodes[p]['cluster'] = 0
cnts = {}
cnts[0] = len(graph.nodes())
while clusters < k - 1:
maxc = -1
maxcnt = 0
for key, val in cnts.items():
if val > maxcnt:
maxcnt = val
maxc = key
s_nodes = [n for n in graph.nodes if graph.nodes[n]['cluster'] == maxc]
s_graph = graph.subgraph(s_nodes)
edgecuts, parts = metis.part_graph(s_graph,
2,
objtype='cut',
ufactor=250)
new_part_cnt = 0
for i, p in enumerate(s_graph.nodes()):
if parts[i] == 1:
graph.nodes[p]['cluster'] = clusters + 1
new_part_cnt = new_part_cnt + 1
cnts[maxc] = cnts[maxc] - new_part_cnt
cnts[clusters + 1] = new_part_cnt
clusters = clusters + 1
edgecuts, parts = metis.part_graph(graph, k)
if df is not None:
df['cluster'] = nx.get_node_attributes(graph, 'cluster').values()
return graph
def k_way_partitioning(k:int,g:nx.Graph):
# COARSENING
start = time.time()
print('starting coarsening phase')
graphs_history , coarsening_history = coarse(g,k=k)
end_coarsening = time.time()
m, s = divmod((end_coarsening - start), 60)
enlapsed_time = "%d minutes and %f seconds" % (m, s)
print('finished coarsening after ', graphs_history.__len__(), ' steps in ', enlapsed_time)
# INITIAL PARTITIONING
print('starting initial partitioning phase')
start_init_part = time.time()
#initial_partitioning = spectral_bisection.initial_partitioning(graphs_history[-1], k)
edge_cut, initial_partitioning = metis.part_graph(graphs_history[-1], k, recursive=True)
end_init_part = time.time()
m, s = divmod((end_init_part - start_init_part), 60)
enlapsed_time = "%d minutes and %f seconds" % (m, s)
print('finished initial partitioning in ', enlapsed_time)
# UNCOARSENING
start_uncoarsening = time.time()
print('starting uncoarsening phase')
final_partitioning = uncoarse(graphs_history,coarsening_history,initial_partitioning,k)
end = time.time()
m, s = divmod((end - start_uncoarsening), 60)
enlapsed_time = "%d minutes and %f seconds" % (m, s)
print('finished un-coarsening in', enlapsed_time)
edge_cut = calculate_edge_cut(graphs_history[0],final_partitioning)
print('the final edge cut is',edge_cut)
m, s = divmod((end - start), 60)
enlapsed_time = "%d minutes and %f seconds" % (m, s)
print('the overall time is',enlapsed_time)
# Write on file the result
output_file(final_partitioning)
# THE RESULT OBTAINED WITH METIS
start_meth = time.time()
edge_cut , metis_partitioning = metis.part_graph(graphs_history[0], k)
end_meth = time.time()
m, s = divmod((end_meth - start_meth), 60)
enlapsed_time = "%d minutes and %f seconds" % (m, s)
print('the edge cut obtained with metis is ',edge_cut)
print('the time taken by metis was ', enlapsed_time)
def partition_graph(adj, idx_nodes, num_clusters):
"""partition a graph by METIS."""
start_time = time.time()
num_nodes = len(idx_nodes)
train_adj = adj[idx_nodes, :][:, idx_nodes]
train_adj_lil = train_adj.tolil()
train_ord_map = dict()
train_adj_lists = [[] for _ in range(num_nodes)]
for i in range(num_nodes):
rows = train_adj_lil[i].rows[0]
# self-edge needs to be removed for valid format of METIS
if i in rows:
rows.remove(i)
train_adj_lists[i] = rows
train_ord_map[idx_nodes[i]] = i
if num_clusters > 1:
_, groups = metis.part_graph(train_adj_lists, num_clusters, seed=1)
else:
groups = [0] * num_nodes
parts = [[] for _ in range(num_clusters)]
for nd_idx in range(num_nodes):
gp_idx = groups[nd_idx]
nd_orig_idx = idx_nodes[nd_idx]
parts[gp_idx].append(nd_orig_idx)
part_size = [len(part) for part in parts]
print('Partitioning done. %f seconds.'%(time.time() - start_time))
print('Max part size %d, min part size %d'%(max(part_size), min(part_size)))
return parts
def metis_prm(csr, B = 16):
import metis
import networkx as nx
import pyamg
import numpy as np
from time import time
bl_ar = []
N = csr.shape[0]
nparts = N/B
G = nx.from_scipy_sparse_matrix(csr)
n, l = metis.part_graph(G, nparts=nparts, recursive=True)
prm = []
tmp = []
for i in xrange(nparts): tmp.append([])
k = 0
for i in l:
tmp[i].append(k)
k += 1
k = 0
for i in tmp:
bl_ar.append(len(i))
k += 1
for j in i:
prm.append(j)
return prm, np.array(bl_ar)
def metis_kway(g, k):
""" Perform METIS k-way partition. """
al = g.get_adjlist()
if metis_import_exception is not None:
raise metis_import_exception
_, m = part_graph(al, k, recursive=False, contig=True, minconn=True)
return m
def metis_bipartition(g, n=2):
""" Perform METIS bipartition. Do n cuts and choose the best. """
al = g.get_adjlist()
if metis_import_exception is not None:
raise metis_import_exception
_, m = part_graph(al, ncuts=n, recursive=False, contig=True, minconn=True)
return array(m)
def get_districts_from_triangles(voters: List[Voter],
raw_triangles: List[Polygon],
n_districts: int, seed: int) -> List[Polygon]:
# triangles = []
# for rt in raw_triangles:
# triangles.append(Triangle(get_voters_in_polygon(rt, voters), rt))
# triangles = sorted(triangles, key=lambda x: x.n_voters)
# free_triangles = list(range(len(triangles)))
# districts = []
# for i in range(n_districts):
# index = random.random.sample(free_triangles, 1)
# d = District()
# d.append_triangle(triangles[index])
# districts.append(d)
# free_triangles.pop(index)
graph = nx.Graph()
graph.add_nodes_from(list(range(len(raw_triangles))))
for index, triangle in enumerate(raw_triangles):
adj_trs = find_adjacent_triangle(index, raw_triangles)
for tr in adj_trs:
graph.add_edge(index, tr)
# Extension
(edgecuts, parts) = metis.part_graph(graph,
n_districts,
ncuts=2,
niter=20,
contig=True)
districts = []
for i in range(n_districts):
districts.append(District())
for index, part in enumerate(parts):
districts[part].append_triangle(raw_triangles[index])
return [d.get_one_polygon() for d in districts]
def process(self):
# divide the graph into partitions such that each partition contains around 50 nodes
(self._edgecuts, self._partitions) = metis.part_graph(
self._data_pointer_nx,
nparts=int(ceil(self._data_pointer_nx.number_of_nodes() / 50.0)))
self._color_count = [1] * (max(self._partitions) + 1)
# run the monte carlo on each of the partitions
self._partition_counts = Counter(self._partitions)
for partition_num in xrange(max(self._partitions) + 1):
while (sum([
self._colored_nodes[idx] for idx in xrange(self._num_nodes)
if self._partitions[idx] == partition_num
]) < self._partition_counts[partition_num]):
# print sum([self._colors[idx] for idx in xrange(self._num_nodes) if self._partitions[idx] == partition_num]), self._partition_counts[partition_num]
self._idle_nodes = [0] * self._num_nodes
for i in xrange(self._num_nodes):
if self._colored_nodes[i] == 1:
self._idle_nodes[i] = 1
temp_mis = self._get_mis(partition_num)
for i in temp_mis:
self._colors[i] = self._color_count[self._partitions[i]]
self._colored_nodes[i] = 1
self._color_count[self._partitions[i]] += 1
# merge the colored partitions and resolve any coloring conflicts
self._resolve_color_conflicts()
def gen_cluster_info(self, use_metis=False):
G = nx.Graph()
G.add_edges_from(
torch.stack(self.edge_index).cpu().numpy().transpose())
if use_metis:
import metis
_, parts = metis.part_graph(G, self.num_clusters)
else:
from sklearn.cluster import KMeans
clustering = KMeans(n_clusters=self.num_clusters,
random_state=0).fit(self.features.cpu())
parts = clustering.labels_
node_clusters = [[] for i in range(self.num_clusters)]
for i, p in enumerate(parts):
node_clusters[p].append(i)
self.central_nodes = np.array([])
self.distance_vec = np.zeros((self.num_nodes, self.num_clusters))
for i in range(self.num_clusters):
subgraph = G.subgraph(node_clusters[i])
center = None
for node in subgraph.nodes:
if center is None or subgraph.degree[node] > subgraph.degree[
center]:
center = node
np.append(self.central_nodes, center)
distance = dict(nx.shortest_path_length(G, source=center))
for node in distance:
self.distance_vec[node][i] = distance[node]
self.distance_vec = torch.tensor(self.distance_vec).float().to(
self.device)
def gen_cluster_info(self):
import metis
G = nx.Graph()
G.add_edges_from(self.edge_index.cpu().t().numpy())
_, parts = metis.part_graph(G, self.num_clusters)
node_clusters = [[] for i in range(self.num_clusters)]
for i, p in enumerate(parts):
node_clusters[p].append(i)
self.central_nodes = np.array([])
self.distance_vec = np.zeros((self.num_nodes, self.num_clusters))
for i in range(self.num_clusters):
subgraph = G.subgraph(node_clusters[i])
center = None
#print(subgraph.nodes)
for node in subgraph.nodes:
if center is None or subgraph.degree[node] > subgraph.degree[
center]:
center = node
np.append(self.central_nodes, center)
distance = dict(nx.shortest_path_length(G, source=center))
for node in distance:
self.distance_vec[node][i] = distance[node]
self.distance_vec = torch.tensor(self.distance_vec).float().to(
self.device)
def part_graph(graph, k, df=None):
edgecuts, parts = metis.part_graph(graph, k)
for i, p in enumerate(graph.nodes()):
graph.node[p]['cluster'] = parts[i]
if df is not None:
df['cluster'] = nx.get_node_attributes(graph, 'cluster').values()
return graph
def start(self):
G = nx.Graph()
for e in self.graph.get_edges():
G.add_edge(e.left_id, e.right_id, weight=e.weight)
G.graph['edge_weight_attr'] = 'weight'
(edgecuts, parts) = metis.part_graph(G, self.n_par)
print(edgecuts)
print(len(parts))
# print(parts)
# for i, p in enumerate(parts):
# print(i, ": ", p)
# for node in G.nodes:
# print(type(G[node]))
# print(G[node].keys())
vertices = {}
# edges = {(e.left_id, e.right_id): e.left_id for e in self.graph.get_edges()}
for i, p in enumerate(parts):
# networkx starts from 0 but we want the nodes to start from 1
vertices[i + 1] = p
return vertices, G.edges
def graphPartition(G, clusterSize):
numClusters = math.ceil(
len(G) / float(clusterSize)
) # heuristic for # of clusters given approximately equal cluster size
print numClusters
(edgecuts,
parts) = metis.part_graph(G, int(numClusters)) # k-way cut algorithm
colors = [
'red', 'blue', 'green', 'orange', 'yellow', 'purple', 'black',
'maroon', 'brown', 'indigo', 'cyan'
]
for i, p in enumerate(parts):
#print i, p
G.node[i]['color'] = colors[p]
nx.drawing.nx_pydot.write_dot(
G, 'example.dot') # writes graph partition into dot file format
result = pgv.AGraph(
'example.dot'
) # load dot format representation of graph to create visualization
result.node_attr.update(shape='circle')
result.node_attr.update(label=' ')
result.node_attr.update(style='filled')
result.layout() # default layout
result.draw('example.svg') # writes visualization as svg file
print("Wrote example.svg")
def create_metis_partitions(networks,
sizes=[2, 4, 8, 16, 32, 64, 128, 256],
use_weights=False,
seed=666):
'''partition all networks and return unified result (partition tables for joint node set)
Parameters
----------
networks : array of networkx Graphs
sizes : list of partitioning sizes
numbers of partitions to split the graphs into
use_weights : (optional) boolean
will use the 'weight' attribute of the networks edges for partitioning (True) or
partition the unweighted graphs (False)
seed : (optional) integer
used as seed for the metis partitioning (for each call the same seed)
'''
p = []
import os
os.environ['METIS_DLL'] = "/usr/local/lib/libmetis.so"
import metis
for g in networks:
partitions = []
if use_weights:
g.graph['edge_weight_attr'] = 'weight'
for i in sizes:
(_, parts) = metis.part_graph(g, i, seed=seed)
partitions.append(parts)
df = DataFrame(partitions).transpose()
df.index = g.nodes()
df.columns = [str(i) + '_' + g.graph['name'] for i in sizes]
p.append(df)
if use_weights:
del g.graph['edge_weight_attr']
return p
def new_partition_helper(G, num_buses, size_bus):
graph_components = []
nodes = list(G.nodes)
cut_size = num_buses
nodes_subgraph = []
parts = None
ran = 0
while True:
(edgecuts, parts) = metis.part_graph(G, cut_size)
nodes_subgraph = [[] for _ in range(max(parts) + 1)]
for i in range(len(parts)):
lnum = parts[i]
vertex = nodes[i]
nodes_subgraph[lnum].append(vertex)
nodes_subgraph = [x for x in nodes_subgraph if len(x) > 0]
if len(nodes_subgraph) > 1:
break
cut_size -= 1
ran += 1
if cut_size == 1 or ran > 4:
return None
for i in nodes_subgraph:
sub_graph = G.subgraph(i)
if nx.number_of_nodes(sub_graph) > size_bus:
r_comps = new_partition_helper(sub_graph, 2, size_bus)
for s in r_comps:
graph_components.append(s)
else:
graph_components.append([sub_graph, nx.number_of_nodes(sub_graph)])
return graph_components
def createEdgesGraph(self, college):
"""
print(graph.edges())
print(graph.nodes())
(cut, parts) = metis.part_graph(graph, 40)
print("hola")
#(cut2, parts2) = metis.partition(graph, 2)
metisGraph = metis.networkx_to_metis(graph)
print(metisGraph)
graph['U27476']['U27661']['weight']=1
print(graph['U27476']['U27661'])
graph.graph['edge_weight_attr'] = 'weight'
metisGraph = metis.networkx_to_metis(graph)
(cutW, partsW) = metis.part_graph(metisGraph, 10)
print("paso esto")
print(graph)
print(metisGraph)
"""
graph = nx.read_gexf("mediumLinkedin.gexf")
weightedGraph = nx.read_gexf("mediumLinkedin.gexf")
# self.draw_graph(graph, parts)
weightedGraph = self.setEdgesWeights(weightedGraph, college)
weightedGraph.graph['edge_weight_attr'] = 'weight'
metisWeightedGraph = metis.networkx_to_metis(weightedGraph)
print("Llego hasta aca")
# self.draw_graph(metisWeightedGraph,parts)
(cutW, partsW) = metis.part_graph(metisWeightedGraph, 5)
print(partsW)
self.draw_graph(graph, partsW)
def part_graph(graph, nparts, node_weight_attr, tpweights, recursive,
**metis_options):
""" Partition graph
:param graph:
:param nparts:
:param node_weight_attr:
:param tpweights:
:param recursive:
:param metis_options:
:return:
"""
# If contiguous partition is requested, only keep main contiguous graph component
if metis_options["contig"]:
graph = max(
(graph.subgraph(c) for c in nx.connected_components(graph)),
key=len)
graph.graph["node_weight_attr"] = node_weight_attr
_, parts = metis.part_graph(graph,
nparts,
tpwgts=tpweights,
ubvec=None,
recursive=recursive,
**metis_options)
partition = [[] for _ in range(nparts)]
for u, i in zip(graph, parts):
partition[i].append(u)
# Only return non-empty parts
return [part for part in partition if part]
def partition_graph(adj, idx_nodes, num_clusters):
"""partition a graph by METIS."""
start_time = time.time()
num_nodes = len(idx_nodes)
num_all_nodes = adj.shape[0]
parts = []
cluster_size = num_all_nodes // num_clusters
num_clusters = num_all_nodes // cluster_size
for i in range(0, num_clusters):
parts += [
list(range(i * cluster_size, i * cluster_size + cluster_size))
]
return None, parts
neighbor_intervals = []
neighbors = []
edge_cnt = 0
neighbor_intervals.append(0)
train_adj_lil = adj[idx_nodes, :][:, idx_nodes].tolil()
train_ord_map = dict()
train_adj_lists = [[] for _ in range(num_nodes)]
for i in range(num_nodes):
rows = train_adj_lil[i].rows[0]
# self-edge needs to be removed for valid format of METIS
if i in rows:
rows.remove(i)
train_adj_lists[i] = rows
neighbors += rows
edge_cnt += len(rows)
neighbor_intervals.append(edge_cnt)
train_ord_map[idx_nodes[i]] = i
if num_clusters > 1:
_, groups = metis.part_graph(train_adj_lists, num_clusters, seed=1)
else:
groups = [0] * num_nodes
part_row = []
part_col = []
part_data = []
parts = [[] for _ in range(num_clusters)]
for nd_idx in range(num_nodes):
gp_idx = groups[nd_idx]
nd_orig_idx = idx_nodes[nd_idx]
parts[gp_idx].append(nd_orig_idx)
for nb_orig_idx in adj[nd_orig_idx].indices:
nb_idx = train_ord_map[nb_orig_idx]
if groups[nb_idx] == gp_idx:
part_data.append(1)
part_row.append(nd_orig_idx)
part_col.append(nb_orig_idx)
part_data.append(0)
part_row.append(num_all_nodes - 1)
part_col.append(num_all_nodes - 1)
part_adj = sp.coo_matrix((part_data, (part_row, part_col))).tocsr()
tf.logging.info('Partitioning done. %f seconds.', time.time() - start_time)
return part_adj, parts
def __cluster_hyperedges_201112(self, k):
metis_graph = networkx_to_metis(self.metagraph)
(_, indices) = metis.part_graph(metis_graph, nparts=k)
print('meta clusters')
print(indices)
indptr = range(len(indices)+1)
data = np.ones(len(indices))
self.meta_clusters = scipy.sparse.csr_matrix((data, indices, indptr), dtype=np.int8).transpose()
def part_graph(graph, k, df=None):
edgecuts, parts = metis.part_graph(graph, 2, objtype='cut', ufactor=250)
# print(edgecuts)
for i, p in enumerate(graph.nodes()):
graph.nodes[p]['cluster'] = parts[i]
if df is not None:
df['cluster'] = nx.get_node_attributes(graph, 'cluster').values()
return graph
def run_metis(input_graph, number_of_parts):
# this function partitions a network into k subgraphs
partition = metis.part_graph(
input_graph,
nparts=number_of_parts,
recursive=True,
)
return partition
def partion_dgraph(dgraph_filename):
partition_graph = nx.read_graphml(dgraph_filename)
if worker_num != 1:
(edgecuts, parts) = metis.part_graph(partition_graph, worker_num)
for i in xrange(0,partition_graph.number_of_nodes()):
id2block[i] = parts[i]
else:
for i in xrange(0,partition_graph.number_of_nodes()):
id2block[i] = 0
def pre_part_graph_gui(self,
graph,
k,
canvas,
ax,
df=None,
plotting=False):
self.ind_fig = 1
self.log.appendPlainText("Begin clustering...")
clusters = 0
for i, p in enumerate(graph.nodes()):
graph.node[p]["cluster"] = 0
cnts = OrderedDict({0: len(graph.nodes())})
while clusters < k - 1:
maxc = -1
maxcnt = 0
for key, val in cnts.items():
if val > maxcnt:
maxcnt = val
maxc = key
s_nodes = [
n for n in graph.node if graph.node[n]["cluster"] == maxc
]
s_graph = graph.subgraph(s_nodes)
edgecuts, parts = metis.part_graph(s_graph,
2,
objtype="cut",
ufactor=250,
seed=42)
new_part_cnt = 0
new_biggest_clust_label = pd.Series(parts).value_counts().idxmax()
for i, p in enumerate(s_graph.nodes()):
if parts[i] == new_biggest_clust_label:
graph.node[p]["cluster"] = clusters + 1
new_part_cnt = new_part_cnt + 1
if plotting is True:
self.plot2d_graph_gui(
graph,
canvas=canvas,
ax=ax,
save_plots=self.save_plots,
ind_fig=self.ind_fig,
print_clust=False,
)
self.ind_fig += 1
cnts[maxc] = cnts[maxc] - new_part_cnt
cnts[clusters + 1] = new_part_cnt
clusters = clusters + 1
# edgecuts, parts = metis.part_graph(graph, k, seed=42)
if df is not None:
df["cluster"] = nx.get_node_attributes(graph, "cluster").values()
return graph
def partGraphIntoRooms(graph, roomSize):
if graph.number_of_nodes() == 0: return ()
partitions = ceil(graph.number_of_nodes() / roomSize)
graph.graph['edge_weight_attr'] = 'weight'
(edgecuts, parts) = ms.part_graph(graph, partitions, recursive=True)
print(edgecuts)
print("Divided into", len(set(parts)), "parts. Goal:", partitions,
"partitions.")
return parts
def fit_predict(self, X, y=None):
""" Partitions a dataset """
if (MultiPart.dataset_id_cache == id(X)):
G = MultiPart.graph_cache
else:
# Build KD-Tree for efficient nearest-neighbors query
kdt = KDTree(X, leaf_size=self.leaf_size, metric=self.metric)
distances, indices = kdt.query(X,
k=self.nearest_neighbors,
return_distance=True)
distances = MinMaxScaler(
feature_range=(0, 1000)).fit_transform(distances)
# Build graph for k-way paprtitioning
G = nx.Graph()
G.add_nodes_from(xrange(len(X)))
# Add distances of nearest neighbors as weighted edges
# The add_edge gets the tuple (index_from, index_to, distance)
for i, x in enumerate(zip(distances, indices)):
for j, dist in enumerate(x[0]):
# We insert opposite of distance since metis can only
# *minimze* edge-cut and we want the cut to be between
# least similar records (which have biggest distance)
G.add_edge(i, x[1][j], weight=int(1000 - dist))
G.graph['edge_weight_attr'] = 'weight'
# Cache the graph
MultiPart.dataset_id_cache = id(X)
MultiPart.graph_cache = G
# Parition the graph
if (self.seed is None):
(edgecuts, parts) = metis.part_graph(G,
self.n_clusters,
objtype='cut')
else:
(edgecuts, parts) = metis.part_graph(G,
self.n_clusters,
objtype='cut',
seed=self.seed)
return parts
def metis_clustering(self):
"""
Clustering the graph with Metis. For details see:
"""
(st, parts) = metis.part_graph(self.graph, self.cluster_number)
self.clusters = list(set(parts))
self.cluster_membership = {
node: membership
for node, membership in enumerate(parts)
}
def get_partition_list(g, psize):
tmp_time = time()
ng = g.to_networkx()
print("getting adj using time{:.4f}".format(time() - tmp_time))
print("run metis with partition size {}".format(psize))
_, nd_group = metis.part_graph(ng, psize)
print("metis finished in {} seconds.".format(time() - tmp_time))
print("train group {}".format(len(nd_group)))
al = arg_list(nd_group)
return al
def partition_graph_metis(G, n_partitions=3):
import metis
assert nx.is_connected(G.to_undirected())
cuts, parts = metis.part_graph(G.to_undirected(),
n_partitions,
contig=True)
colors = ['red', 'blue', 'green', 'purple']
for i, part in enumerate(parts):
G.nodes[i]['color'] = colors[part]
nx.nx_pydot.write_dot(G, 'graph_partitions.dot')
return cuts, parts
def decompose(self, problem, n):
g = InteractionGraph(problem)
edgecuts, parts = metis.part_graph(g, n, recursive=False, objtype="cut",
numbering=0, minconn=True, iptype="edge")
groups = []
for i in xrange(n):
groups.append([])
for i, j in enumerate(parts):
groups[j].append(i)
print parts
print groups
def part_graph(graph, k, df=None):
"""return the input graph with the clustering obtained through mincut-bisection"""
edgecuts, parts = metis.part_graph(graph,
2,
objtype="cut",
ufactor=250,
seed=42)
# print(edgecuts)
for i, p in enumerate(graph.nodes()):
graph.node[p]["cluster"] = parts[i]
if df is not None:
df["cluster"] = nx.get_node_attributes(graph, "cluster").values()
return graph
def create_partitions(self):
#print "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"*10
self.partitioned_graph = self.topo_graph.copy()
nx.write_dot(self.partitioned_graph, 'slick.dot')
#http://metis.readthedocs.org/en/latest/
# We are using off the shelf software to partition the network.
num_partitions = self.get_num_partitions( )
if num_partitions > 1:
# For now using the default partitioning algorithm.
# Should experiment with different types and different partitioning algorithms.
# Or ir does not matter whatever partition algorithm we use.
(objective_function, partitions) = metis.part_graph(self.partitioned_graph, nparts = num_partitions)
# For debugging
#print "Objective Function:"*100, objective_function
print "Partitions:", partitions
# Add more colors to this array if get_num_partitions is > 4
colors = ['red','blue','green','orange']
node_ids = [ ]
for node in self.partitioned_graph.nodes():
node_ids.append(node)
for i, p in enumerate(partitions):
# Please note p starts from zero, one, two etc.
#self.partitioned_graph.node[i+1] = {'color': colors[p], 'part_number': p}
node_id = node_ids[i]
self.partitioned_graph.node[node_id] = {'color': colors[p], 'part_number': p}
else:
(objective_function, partitions) = metis.part_graph(self.partitioned_graph, nparts = 2)
colors = ['red','blue','green','orange']
node_ids = [ ]
for node in self.partitioned_graph.nodes():
node_ids.append(node)
for i, p in enumerate(partitions):
p = 0
node_id = node_ids[i]
self.partitioned_graph.node[node_id] = {'color': colors[p], 'part_number': p}
nx.write_dot(self.partitioned_graph, 'slick_parts.dot')
def metis_clusters(G, num_clusters, additionalClusters=0):
G.graph["edge_weight_attr"] = "weight"
# G = metis.networkx_to_metis(G)
if len(G.nodes()) == 0:
print "Error! Graph has 0 nodes"
sys.exit()
elif len(G.nodes()) == 1:
return [0]
elif len(G.nodes()) < num_clusters:
return range(len(G.nodes()))
(edgecuts, parts) = metis.part_graph(
G, nparts=num_clusters + additionalClusters, recursive=False, niter=1000, ufactor=700
)
return parts
def offline_b_lin_method(nx_graph, attempt_split_parts=2, prob=PROB, approx_rank=False):
"""
:param nx_graph: networkx graph
:param attempt_split_parts:
to split the graph into several parts
note: might get fewer cuts desired
:param prob: probability to restart to origin pos
:param approx_rank: the similarity to decompose the W2 matrix
:return: W_telta, Q1_I, U, A, V
:note: if the W2 is a singular matrix then A add some value to it
"""
# phase 1: graph partition
import metis
G = metis.networkx_to_metis(nx_graph)
(objval, parts) = metis.part_graph(G, attempt_split_parts)
# we should normalize parts since we CAN get the FEWER parts
# record all node index in one partition {partitionId:[nodeIds]}
groups = {}
for r, gn in enumerate(parts):
if gn not in groups.keys():
groups[gn] = []
groups[gn].append(r)
for key in groups.keys():
groups[key] = sorted(groups[key])
# print (objval, parts)
# we build the W_telta as a normalized matrix
node_size = len(nx_graph.nodes())
# first we construct the index
row_idx = []
for part in groups.keys():
for idx in groups[part]:
row_idx.append(idx)
# represent and normalize the matrix
# we could use other methods to normalize to see the effect
W_telta = numpy_helper.normalize_matrix(nx_graph)
# phase 2 and 3
# w1 contains all within partition link
W1_group = {}
W1 = numpy.matrix([[0.0] * node_size] * node_size)
cur_k_row = 0
for gn in groups.keys():
matrix_len = len(groups[gn])
W1_group[gn] = numpy.matrix([[0.0]*matrix_len]*matrix_len)
for i in range(0, matrix_len):
for j in range(0, matrix_len):
W1_group[gn][i, j] = W_telta[cur_k_row+i, cur_k_row+j]
W1[cur_k_row+i, cur_k_row+j] = W_telta[cur_k_row+i, cur_k_row+j]
cur_k_row += matrix_len
# w2 contains all without partition link
W2 = W_telta - W1
# phase 4
# pre-compute Q
Q1_I_group = {}
for key in W1_group.keys():
Q1_I_group[key] = \
(numpy.identity(W1_group[key].shape[0]) - prob*W1_group[key]).I
# phase 5
# do low rand approx
# currently we use the default
# *we may further use other approx to test*
# #pymf#
U, S, V = low_rank_approx_svd(W2, approx_rank)
# TODO if u v s is not full rank matrix we need to compute NB_LIN
try:
S_I = S.I
except Exception:
# make it reverse
S += 1e-15 *numpy.identity(S.shape[0])
# phase 6 construct Q1_I
Q1_I = numpy.matrix([[0.0]*node_size]*node_size)
diag_index = 0
for gn in groups.keys():
if gn in Q1_I_group.keys():
sz = Q1_I_group[gn].shape[0]
for i in range(0, sz):
for j in range(0, sz):
Q1_I[i+diag_index, j+diag_index] = Q1_I_group[gn][i, j]
diag_index += sz
A = (S.I - prob*V*Q1_I*U).I
return W_telta, Q1_I, U, A, V
f.close()
# 答えデータ読み込み
answer_dict={}
f = open(answer, 'rb')
dataReader = csv.reader(f)
for row in dataReader:
answer_dict[row[0]]=row[1]
f.close()
# グラフ分割
# partsはintのlist
(edgecuts, parts) = metis.part_graph(G,nparts=partition_N, recursive=True)
for i, part in enumerate(parts): #each_with_index
if G.node[i]:
pprint(G.node[i]['word'])
G.node[i]['transnum']=part
partition_G.node[i]['transnum']=part
# print "part:"
# pprint(part) #int
lang=nx.get_node_attributes(G,'lang')
word=nx.get_node_attributes(G,'word')
transnum=nx.get_node_attributes(G,'transnum')
#transnumが同じならpartition_Gにも枝をつける
for n1, n2 in G.edges_iter():
if G.node[n1] and G.node[n2]:
import networkx as nx
import metis
G = metis.example_networkx()
mg = metis.networkx_to_metis(G)
(edgecuts, parts) = metis.part_graph(G, 3)
print("edgecuts", edgecuts)
print("parts", parts)
colors = ['red','blue','green']
for i, p in enumerate(parts):
G.node[i]['color'] = colors[p]
nx.draw(G)
nx.write_dot(G, 'example.dot') # Requires pydot or pygraphviz
for ie in range(nelem):
#print "element", ie
#loop over element nodes (local numbering)
for i in elemnodes[ie]:
#print " node", i, " connectivity ", nodalconnectivity[i]
for k in nodalconnectivity[i]:
if k != ie:
adj[ie].add(k)
adj[k].add(ie)
#print adj
#done; call metis now
try:
from metis import part_graph
cuts, part_vert = part_graph(adj, nparts)
except:
print "metis module not installed or internal metis error encountered"
exit(0)
#print "Metis"
#print " part_vert :", part_vert
#print " cuts:", cuts
# write partitioned mesh on output
print "Partition local_nodes shared_nodes elements"
print "----------------------------------------------"
nodalstatuses, nodalpart = classifyNodes(part_vert)
for i in range (nparts):
writePartition(i, part_vert, nodalstatuses, nodalpart)
nStrand, nParticle, factor, refFrame, radius, frameFilter = pkl.load(file(prefix[0]+'info.dump', 'r'))
strandGraph = pkl.load(file(prefix[0]+'mgB.dump'))
# step 3
_g = strandGraph
import networkx as nx
import metis
import metis_graph as mg
G = nx.Graph()
G.add_nodes_from(range(nStrand))
itr = mg.UndirectedIterator(_g)
for edge in itr:
G.add_edge(edge[0], edge[1], weight=edge[2])
cut, vers = metis.part_graph(G, nGroup)
import pymetis
cut2, vers2 = pymetis.part_graph(nGroup, xadj=_g.xadj, adjncy=_g.adjncy, eweights=_g.eweights)
f = open(prefix[0]+".group","wb")
import struct
f.write(struct.pack('i', len(vers)))
for i in vers:
f.write(struct.pack('i', i))
f.close()
import ipdb; ipdb.set_trace()
# rand, opt, worst
for iiii in range(3):
opt = guideOpts[iiii]
sys.exit()
f = sys.argv[1];
if f.endswith(".dot"):
dot = True
elif f.endswith(".adjlist"):
dot = False
else:
print "Usage: graphProcessor.py <path to file>"
sys.exit()
# Load the graph
G = ge.LoadGraphFromDot(f) if dot else ge.LoadGraphFromAdjList(f)
# Trim the leaves to make the graph look a little nicer.
ge.TrimGraphLeaves(G)
# write to dot file
ge.WriteGraphToDot(G, "newout.dot")
(edgecuts, parts) = metis.part_graph(G, 4, seed=1234);
colors = ['blue', 'green', 'cyan', 'purple', 'brown'];
# Update the colors of the graph nodes.
for i,node in enumerate(parts):
index = G.nodes()[i]
G.node[index]["color"] = colors[node]
ge.WriteGraphToDot(G,"partitionedTrimmed.dot")
