File size: 3,846 Bytes
8aa674c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
# copy from https://github.dev/frostinassiky/gtad/blob/3f145d5d3a8ce7ac8d2b985934dbb575ca1b7981/gtad_lib/models.py
import torch
import torch.nn as nn
import numpy as np
from ..builder import MODELS
@MODELS.register_module()
class GCNeXt(nn.Module):
def __init__(self, in_channels, out_channels, k=3, groups=32):
super().__init__()
width_group = 4
self.k = k
self.groups = groups
width = width_group * groups
# temporal graph
self.tconvs = nn.Sequential(
nn.Conv1d(in_channels, width, kernel_size=1),
nn.ReLU(True),
nn.Conv1d(width, width, kernel_size=3, groups=groups, padding=1),
nn.ReLU(True),
nn.Conv1d(width, out_channels, kernel_size=1),
)
# semantic graph
self.sconvs = nn.Sequential(
nn.Conv2d(in_channels * 2, width, kernel_size=1),
nn.ReLU(True),
nn.Conv2d(width, width, kernel_size=1, groups=groups),
nn.ReLU(True),
nn.Conv2d(width, out_channels, kernel_size=1),
)
self.relu = nn.ReLU(True)
def forward(self, x, masks=None):
identity = x # residual
tout = self.tconvs(x) # conv on temporal graph
x_f = get_graph_feature(x, k=self.k, style=1) # (bs,ch,100) -> (bs, 2ch, 100, k)
sout = self.sconvs(x_f) # conv on semantic graph
sout = sout.max(dim=-1, keepdim=False)[0] # (bs, ch, 100, k) -> (bs, ch, 100)
out = tout + identity + sout # fusion
if masks != None:
return self.relu(out) * masks.unsqueeze(1).float().detach(), masks
else:
return self.relu(out)
# dynamic graph from knn
def knn(x, y=None, k=10):
"""
:param x: BxCxN
:param y: BxCxM
:param k: scalar
:return: BxMxk
"""
if y is None:
y = x
inner = -2 * torch.matmul(y.transpose(2, 1), x)
xx = torch.sum(x**2, dim=1, keepdim=True)
yy = torch.sum(y**2, dim=1, keepdim=True)
pairwise_distance = -xx - inner - yy.transpose(2, 1)
_, idx = pairwise_distance.topk(k=k, dim=-1) # (batch_size, num_points, k)
return idx
# get graph feature
def get_graph_feature(x, prev_x=None, k=20, idx_knn=None, r=-1, style=0):
"""
:param x:
:param prev_x:
:param k:
:param idx:
:param r: output downsampling factor (-1 for no downsampling)
:param style: method to get graph feature
:return:
"""
batch_size = x.size(0)
num_points = x.size(2) # if prev_x is None else prev_x.size(2)
x = x.view(batch_size, -1, num_points)
if idx_knn is None:
idx_knn = knn(x=x, y=prev_x, k=k) # (batch_size, num_points, k)
else:
k = idx_knn.shape[-1]
# print(idx_knn.shape)
device = x.device # torch.device('cuda')
idx_base = torch.arange(0, batch_size, device=device).view(-1, 1, 1) * num_points
idx = idx_knn + idx_base
idx = idx.view(-1)
_, num_dims, _ = x.size()
x = x.transpose(2, 1).contiguous() # (batch_size, num_points, num_dims) -> (batch_size*num_points, num_dims)
feature = x.view(batch_size * num_points, -1)[idx, :]
feature = feature.view(batch_size, num_points, k, num_dims)
x = x.view(batch_size, num_points, 1, num_dims).repeat(1, 1, k, 1)
if style == 0: # use offset as feature
feature = torch.cat((feature - x, x), dim=3).permute(0, 3, 1, 2)
elif style == 1: # use feature as feature
feature = torch.cat((feature, x), dim=3).permute(0, 3, 1, 2)
else: # style == 2:
feature = feature.permute(0, 3, 1, 2)
# downsample if needed
if r != -1:
select_idx = torch.from_numpy(np.random.choice(feature.size(2), feature.size(2) // r, replace=False))
feature = feature[:, :, select_idx.to(device=device), :]
return feature.contiguous()
|