def __init__(self,
num_scales,
in_channels,
out_channels,
A_binary,
disentangled_agg=True,
use_mask=True,
dropout=0,
activation='relu'):
super().__init__()
self.num_scales = num_scales
if disentangled_agg:
A_powers = [k_adjacency(A_binary, k, with_self=True) for k in range(num_scales)]
A_powers = np.concatenate([normalize_adjacency_matrix(g) for g in A_powers])
else:
A_powers = [A_binary + np.eye(len(A_binary)) for k in range(num_scales)]
A_powers = [normalize_adjacency_matrix(g) for g in A_powers]
A_powers = [np.linalg.matrix_power(g, k) for k, g in enumerate(A_powers)]
A_powers = np.concatenate(A_powers)
self.A_powers = torch.Tensor(A_powers)
self.use_mask = use_mask
if use_mask:
# NOTE: the inclusion of residual mask appears to slow down training noticeably
self.A_res = nn.init.uniform_(nn.Parameter(torch.Tensor(self.A_powers.shape)), -1e-6, 1e-6)
self.mlp = MLP(in_channels * num_scales, [out_channels], dropout=dropout, activation=activation)
def __init__(self,
in_channels,
out_channels,
A_binary,
num_scales,
window_size,
disentangled_agg=True,
use_Ares=True,
residual=False,
dropout=0,
activation='relu'):
super().__init__()
self.num_scales = num_scales
self.window_size = window_size
self.use_Ares = use_Ares
A = self.build_spatial_temporal_graph(A_binary, window_size)
if disentangled_agg:
A_scales = [k_adjacency(A, k, with_self=True) for k in range(num_scales)]
A_scales = np.concatenate([normalize_adjacency_matrix(g) for g in A_scales])
else:
# Self-loops have already been included in A
A_scales = [normalize_adjacency_matrix(A) for k in range(num_scales)]
A_scales = [np.linalg.matrix_power(g, k) for k, g in enumerate(A_scales)]
A_scales = np.concatenate(A_scales)
self.A_scales = torch.Tensor(A_scales)
self.V = len(A_binary)
if use_Ares:
self.A_res = nn.init.uniform_(nn.Parameter(torch.randn(self.A_scales.shape)), -1e-6, 1e-6)
else:
self.A_res = torch.tensor(0)
self.mlp = MLP(in_channels * num_scales, [out_channels], dropout=dropout, activation='linear')
# Residual connection
if not residual:
self.residual = lambda x: 0
elif (in_channels == out_channels):
self.residual = lambda x: x
else:
self.residual = MLP(in_channels, [out_channels], activation='linear')
self.act = activation_factory(activation)
self.global_pool = nn.AdaptiveAvgPool2d(1)
self.conv_down = nn.Conv2d(
out_channels, out_channels // 4, kernel_size=1, bias=False)
# nn.init.constant_(self.conv_down.weight, 0)
nn.init.normal_(self.conv_down.weight, 0, 0.001)
self.conv_up = nn.Conv2d(
out_channels // 4, out_channels, kernel_size=1, bias=False)
nn.init.constant_(self.conv_up.weight, 0)
self.relu = nn.ReLU()
self.sig = nn.Sigmoid()
def __init__(self, *args, **kwargs):
self.edges = neighbor
self.num_nodes = num_node
self.self_loops = [(i, i) for i in range(self.num_nodes)]
self.A_binary = tools.get_adjacency_matrix(self.edges, self.num_nodes)
self.A_binary_with_I = tools.get_adjacency_matrix(self.edges + self.self_loops, self.num_nodes)
self.A = tools.normalize_adjacency_matrix(self.A_binary)
