| import numpy as np |
|
|
|
|
| def edge2mat(link, num_node): |
| A = np.zeros((num_node, num_node)) |
| for i, j in link: |
| A[j, i] = 1 |
| return A |
|
|
|
|
| def normalize_digraph(A): |
| Dl = np.sum(A, 0) |
| h, w = A.shape |
| Dn = np.zeros((w, w)) |
| for i in range(w): |
| if Dl[i] > 0: |
| Dn[i, i] = Dl[i] ** (-1) |
| AD = np.dot(A, Dn) |
| return AD |
|
|
|
|
| def get_spatial_graph(num_node, self_link, inward, outward): |
| I = edge2mat(self_link, num_node) |
| In = normalize_digraph(edge2mat(inward, num_node)) |
| Out = normalize_digraph(edge2mat(outward, num_node)) |
| A = np.stack((I, In, Out)) |
| return A |
|
|
|
|
| import numpy as np |
|
|
| def get_sgp_mat(num_in, num_out, link): |
| A = np.zeros((num_in, num_out)) |
| for i, j in link: |
| A[i, j] = 1 |
| A_norm = A / np.sum(A, axis=0, keepdims=True) |
| return A_norm |
|
|
| def edge2mat(link, num_node): |
| A = np.zeros((num_node, num_node)) |
| for i, j in link: |
| A[j, i] = 1 |
| return A |
|
|
| def get_k_scale_graph(scale, A): |
| if scale == 1: |
| return A |
| An = np.zeros_like(A) |
| A_power = np.eye(A.shape[0]) |
| for k in range(scale): |
| A_power = A_power @ A |
| An += A_power |
| An[An > 0] = 1 |
| return An |
|
|
| def normalize_digraph(A): |
| Dl = np.sum(A, 0) |
| h, w = A.shape |
| Dn = np.zeros((w, w)) |
| for i in range(w): |
| if Dl[i] > 0: |
| Dn[i, i] = Dl[i] ** (-1) |
| AD = np.dot(A, Dn) |
| return AD |
|
|
|
|
| def get_spatial_graph(num_node, self_link, inward, outward): |
| I = edge2mat(self_link, num_node) |
| In = normalize_digraph(edge2mat(inward, num_node)) |
| Out = normalize_digraph(edge2mat(outward, num_node)) |
| A = np.stack((I, In, Out)) |
| return A |
|
|
| def normalize_adjacency_matrix(A): |
| node_degrees = A.sum(-1) |
| degs_inv_sqrt = np.power(node_degrees, -0.5) |
| norm_degs_matrix = np.eye(len(node_degrees)) * degs_inv_sqrt |
| return (norm_degs_matrix @ A @ norm_degs_matrix).astype(np.float32) |
|
|
|
|
| def k_adjacency(A, k, with_self=False, self_factor=1): |
| assert isinstance(A, np.ndarray) |
| I = np.eye(len(A), dtype=A.dtype) |
| if k == 0: |
| return I |
| Ak = np.minimum(np.linalg.matrix_power(A + I, k), 1) \ |
| - np.minimum(np.linalg.matrix_power(A + I, k - 1), 1) |
| if with_self: |
| Ak += (self_factor * I) |
| return Ak |
|
|
| def get_multiscale_spatial_graph(num_node, self_link, inward, outward): |
| I = edge2mat(self_link, num_node) |
| A1 = edge2mat(inward, num_node) |
| A2 = edge2mat(outward, num_node) |
| A3 = k_adjacency(A1, 2) |
| A4 = k_adjacency(A2, 2) |
| A1 = normalize_digraph(A1) |
| A2 = normalize_digraph(A2) |
| A3 = normalize_digraph(A3) |
| A4 = normalize_digraph(A4) |
| A = np.stack((I, A1, A2, A3, A4)) |
| return A |
|
|
| def get_adjacency_matrix(edges, num_nodes): |
| A = np.zeros((num_nodes, num_nodes), dtype=np.float32) |
| for edge in edges: |
| A[edge] = 1. |
| return A |
|
|
| def get_uniform_graph(num_node, self_link, neighbor): |
| A = normalize_digraph(edge2mat(neighbor + self_link, num_node)) |
| return A |
|
|
