|
|
import torch |
|
|
import torch.nn as nn |
|
|
from ..builder import MODELS |
|
|
|
|
|
|
|
|
|
|
|
def knn(x, y=None, k=10): |
|
|
if y is None: |
|
|
y = x |
|
|
dif = torch.sum((x.unsqueeze(2) - y.unsqueeze(3)) ** 2, dim=1) |
|
|
idx_org = dif.topk(k=k, dim=-1, largest=False)[1] |
|
|
|
|
|
return idx_org |
|
|
|
|
|
|
|
|
def get_neigh_idx_semantic(x, n_neigh): |
|
|
B, _, num_prop_v = x.shape |
|
|
neigh_idx = knn(x, k=n_neigh).to(dtype=torch.float32) |
|
|
shift = torch.tensor(range(B), dtype=torch.float32, device=x.device) * num_prop_v |
|
|
shift = shift[:, None, None].repeat(1, num_prop_v, n_neigh) |
|
|
neigh_idx = (neigh_idx + shift).view(-1) |
|
|
return neigh_idx |
|
|
|
|
|
|
|
|
class NeighConv(nn.Module): |
|
|
def __init__(self, feat_channels, num_neigh, nfeat_mode, agg_type, edge_weight): |
|
|
super(NeighConv, self).__init__() |
|
|
self.num_neigh = num_neigh |
|
|
self.nfeat_mode = nfeat_mode |
|
|
self.agg_type = agg_type |
|
|
self.edge_weight = edge_weight |
|
|
|
|
|
self.mlp = nn.Linear(feat_channels * 2, feat_channels) |
|
|
|
|
|
def forward(self, x): |
|
|
bs, C, num_frm = x.shape |
|
|
neigh_idx = get_neigh_idx_semantic(x, self.num_neigh) |
|
|
|
|
|
feat_prop = x.permute(0, 2, 1).reshape(-1, C) |
|
|
feat_neigh = feat_prop[neigh_idx.to(torch.long)] |
|
|
f_neigh_temp = feat_neigh.view(-1, self.num_neigh, feat_neigh.shape[-1]) |
|
|
|
|
|
if self.nfeat_mode == "feat_ctr": |
|
|
feat_neigh = torch.cat( |
|
|
( |
|
|
feat_neigh.view(-1, self.num_neigh, feat_prop.size(-1)), |
|
|
feat_prop.view(-1, 1, feat_prop.size(-1)).repeat(1, self.num_neigh, 1), |
|
|
), |
|
|
dim=-1, |
|
|
) |
|
|
elif self.nfeat_mode == "dif_ctr": |
|
|
feat_prop = feat_prop.view(-1, 1, feat_prop.size(-1)).repeat(1, self.num_neigh, 1) |
|
|
diff = feat_neigh.view(-1, self.num_neigh, feat_prop.size(-1)) - feat_prop |
|
|
feat_neigh = torch.cat((diff, feat_prop), dim=-1) |
|
|
elif self.nfeat_mode == "feat": |
|
|
feat_neigh = feat_neigh.view(-1, self.num_neigh, feat_prop.size(-1)) |
|
|
|
|
|
feat_neigh_out = self.mlp(feat_neigh) |
|
|
if self.edge_weight == "true": |
|
|
weight = torch.matmul(f_neigh_temp, feat_prop.unsqueeze(2)) |
|
|
weight_denom1 = torch.sqrt(torch.sum(f_neigh_temp * f_neigh_temp, dim=2, keepdim=True)) |
|
|
weight_denom2 = torch.sqrt(torch.sum(feat_prop.unsqueeze(2) * feat_prop.unsqueeze(2), dim=1, keepdim=True)) |
|
|
weight = (weight / torch.matmul(weight_denom1, weight_denom2)).squeeze(2) |
|
|
feat_neigh_out = feat_neigh_out * weight.unsqueeze(2) |
|
|
|
|
|
if self.agg_type == "max": |
|
|
feat_neigh_out = feat_neigh_out.max(dim=1, keepdim=False)[0] |
|
|
elif self.agg_type == "mean": |
|
|
feat_neigh_out = feat_neigh_out.mean(dim=1, keepdim=False) |
|
|
return feat_neigh_out.view(bs, num_frm, -1).permute(0, 2, 1) |
|
|
|
|
|
|
|
|
class xGN(nn.Module): |
|
|
def __init__( |
|
|
self, |
|
|
feat_channels, |
|
|
stride, |
|
|
gcn_kwargs=dict(num_neigh=10, nfeat_mode="feat_ctr", agg_type="max", edge_weight="false"), |
|
|
): |
|
|
super(xGN, self).__init__() |
|
|
|
|
|
self.tconv1 = nn.Conv1d( |
|
|
in_channels=feat_channels, |
|
|
out_channels=feat_channels, |
|
|
kernel_size=3, |
|
|
stride=1, |
|
|
padding=1, |
|
|
groups=1, |
|
|
) |
|
|
|
|
|
self.nconv1 = NeighConv(feat_channels, **gcn_kwargs) |
|
|
|
|
|
self.relu = nn.ReLU(inplace=True) |
|
|
self.maxpool = nn.MaxPool1d(kernel_size=3, stride=stride, padding=1) |
|
|
|
|
|
def forward(self, x, mask=None): |
|
|
""" |
|
|
Args: |
|
|
x: Feature from previous layer, tensor size (B, C, T) |
|
|
Returns: |
|
|
output: tensor size (B, C, T) |
|
|
""" |
|
|
|
|
|
|
|
|
c_out = self.tconv1(x) |
|
|
|
|
|
|
|
|
g_out = self.nconv1(x) |
|
|
|
|
|
out = self.relu(c_out + g_out) |
|
|
out = self.maxpool(out) |
|
|
|
|
|
if mask is not None: |
|
|
mask = self.maxpool(mask.float()).bool() |
|
|
out = out * mask.unsqueeze(1).to(out.dtype).detach() |
|
|
return out, mask |
|
|
else: |
|
|
return out |
|
|
|
