Initial commit

Author: FenyuHu

tensorflow_code/__init__.py

@@ -0,0 +1,2 @@
+from __future__ import print_function
+from __future__ import division

tensorflow_code/coarsen.py

@@ -0,0 +1,138 @@
+from collections import defaultdict
+from graph import Graph
+import numpy as np
+from utils import cmap2C
+
+
+def normalized_adj_wgt(graph):
+    adj_wgt = graph.adj_wgt
+    adj_idx = graph.adj_idx
+    norm_wgt = np.zeros(adj_wgt.shape, dtype=np.float32)
+    degree = graph.degree
+    for i in range(graph.node_num):
+        for j in range(adj_idx[i], adj_idx[i + 1]):
+            neigh = graph.adj_list[j]
+            norm_wgt[j] = adj_wgt[neigh] / np.sqrt(degree[i] * degree[neigh])
+    return norm_wgt
+
+###############################################
+# This section of code adapted from jiongqianliang/MILE #
+# http://jiongqianliang.com/MILE/ #
+###############################################
+
+def generate_hybrid_matching(max_node_wgt, graph):
+    '''Generate matchings using the hybrid method. It changes the cmap in graph object, 
+    return groups array and coarse_graph_size.'''
+    node_num = graph.node_num
+    adj_list = graph.adj_list  # big array for neighbors.
+    adj_idx = graph.adj_idx  # beginning idx of neighbors.
+    adj_wgt = graph.adj_wgt  # weight on edge
+    node_wgt = graph.node_wgt  # weight on node
+    cmap = graph.cmap
+    norm_adj_wgt = normalized_adj_wgt(graph)
+    groups = []  # a list of groups, each group corresponding to one coarse node.
+    matched = [False] * node_num
+
+    # SEM: structural equivalence matching.
+    jaccard_idx_preprocess(graph, matched, groups)
+    #print("# groups have perfect jaccard idx (1.0): %d" % len(groups))
+    degree = [adj_idx[i + 1] - adj_idx[i] for i in range(0, node_num)]
+
+    sorted_idx = np.argsort(degree)
+    for idx in sorted_idx:
+        if matched[idx]:
+            continue
+        max_idx = idx
+        max_wgt = -1
+        for j in range(adj_idx[idx], adj_idx[idx + 1]):
+            neigh = adj_list[j]
+            if neigh == idx:  # KEY: exclude self-loop. Otherwise, mostly matching with itself.
+                continue
+            curr_wgt = norm_adj_wgt[j]
+            if ((not matched[neigh]) and max_wgt < curr_wgt and node_wgt[idx] + node_wgt[neigh] <= max_node_wgt):
+                max_idx = neigh
+                max_wgt = curr_wgt
+        # it might happen that max_idx is idx, which means cannot find a match for the node. 
+        matched[idx] = matched[max_idx] = True
+        if idx == max_idx:
+            groups.append([idx])
+        else:
+            groups.append([idx, max_idx])
+    coarse_graph_size = 0
+    for idx in range(len(groups)):
+        for ele in groups[idx]:
+            cmap[ele] = coarse_graph_size
+        coarse_graph_size += 1
+    return (groups, coarse_graph_size)
+
+
+def jaccard_idx_preprocess(graph, matched, groups):
+    '''Use hashmap to find out nodes with exactly same neighbors.'''
+    neighs2node = defaultdict(list)
+    for i in range(graph.node_num):
+        neighs = str(sorted(graph.get_neighs(i)))
+        neighs2node[neighs].append(i)
+    for key in neighs2node.keys():
+        g = neighs2node[key]
+        if len(g) > 1:
+            for node in g:
+                matched[node] = True
+            groups.append(g)
+    return
+
+
+def create_coarse_graph(graph, groups, coarse_graph_size):
+    '''create the coarser graph and return it based on the groups array and coarse_graph_size'''
+    coarse_graph = Graph(coarse_graph_size, graph.edge_num)
+    coarse_graph.finer = graph
+    graph.coarser = coarse_graph
+    cmap = graph.cmap
+    adj_list = graph.adj_list
+    adj_idx = graph.adj_idx
+    adj_wgt = graph.adj_wgt
+    node_wgt = graph.node_wgt
+
+    coarse_adj_list = coarse_graph.adj_list
+    coarse_adj_idx = coarse_graph.adj_idx
+    coarse_adj_wgt = coarse_graph.adj_wgt
+    coarse_node_wgt = coarse_graph.node_wgt
+    coarse_degree = coarse_graph.degree
+
+    coarse_adj_idx[0] = 0
+    nedges = 0  # number of edges in the coarse graph
+    for idx in range(len(groups)):  # idx in the graph
+        coarse_node_idx = idx
+        neigh_dict = dict()  # coarser graph neighbor node --> its location idx in adj_list.
+        group = groups[idx]
+        for i in range(len(group)):
+            merged_node = group[i]
+            if (i == 0):
+                coarse_node_wgt[coarse_node_idx] = node_wgt[merged_node]
+            else:
+                coarse_node_wgt[coarse_node_idx] += node_wgt[merged_node]
+
+            istart = adj_idx[merged_node]
+            iend = adj_idx[merged_node + 1]
+            for j in range(istart, iend):
+                k = cmap[adj_list[
+                    j]]  # adj_list[j] is the neigh of v; k is the new mapped id of adj_list[j] in coarse graph.
+                if k not in neigh_dict:  # add new neigh
+                    coarse_adj_list[nedges] = k
+                    coarse_adj_wgt[nedges] = adj_wgt[j]
+                    neigh_dict[k] = nedges
+                    nedges += 1
+                else:  # increase weight to the existing neigh
+                    coarse_adj_wgt[neigh_dict[k]] += adj_wgt[j]
+                # add weights to the degree. For now, we retain the loop. 
+                coarse_degree[coarse_node_idx] += adj_wgt[j]
+
+        coarse_node_idx += 1
+        coarse_adj_idx[coarse_node_idx] = nedges
+
+    coarse_graph.edge_num = nedges
+
+    coarse_graph.resize_adj(nedges)
+    C = cmap2C(cmap)  # construct the matching matrix.
+    graph.C = C
+    coarse_graph.A = C.transpose().dot(graph.A).dot(C)
+    return coarse_graph