import torch import torch.nn as nn from lib.layers import ResnetBlockFC def maxpool(x, dim=-1, keepdim=False): ''' Performs a maxpooling operation. Args: x (tensor): input dim (int): dimension of pooling keepdim (bool): whether to keep dimensions ''' out, _ = x.max(dim=dim, keepdim=keepdim) return out class SimplePointnet(nn.Module): ''' PointNet-based encoder network. Args: c_dim (int): dimension of latent code c dim (int): input points dimension hidden_dim (int): hidden dimension of the network ''' def __init__(self, c_dim=128, dim=3, hidden_dim=512): super().__init__() self.c_dim = c_dim self.fc_pos = nn.Linear(dim, 2*hidden_dim) self.fc_0 = nn.Linear(2*hidden_dim, hidden_dim) self.fc_1 = nn.Linear(2*hidden_dim, hidden_dim) self.fc_2 = nn.Linear(2*hidden_dim, hidden_dim) self.fc_3 = nn.Linear(2*hidden_dim, hidden_dim) self.fc_c = nn.Linear(hidden_dim, c_dim) self.actvn = nn.ReLU() self.pool = maxpool def forward(self, p): batch_size, T, D = p.size() # output size: B x T X F net = self.fc_pos(p) net = self.fc_0(self.actvn(net)) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.fc_1(self.actvn(net)) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.fc_2(self.actvn(net)) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.fc_3(self.actvn(net)) # Recude to B x F net = self.pool(net, dim=1) c = self.fc_c(self.actvn(net)) return c class ResnetPointnet(nn.Module): ''' PointNet-based encoder network with ResNet blocks. Args: c_dim (int): dimension of latent code c dim (int): input points dimension hidden_dim (int): hidden dimension of the network ''' def __init__(self, c_dim=128, dim=3, hidden_dim=512): super().__init__() self.c_dim = c_dim self.fc_pos = nn.Linear(dim, 2*hidden_dim) self.block_0 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_1 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_2 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_3 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_4 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.fc_c = nn.Linear(hidden_dim, c_dim) self.actvn = nn.ReLU() self.pool = maxpool def forward(self, p): batch_size, T, D = p.size() # output size: B x T X F net = self.fc_pos(p) net = self.block_0(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_1(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_2(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_3(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_4(net) # Recude to B x F net = self.pool(net, dim=1) c = self.fc_c(self.actvn(net)) return c class ResnetPointnet2Stream(nn.Module): ''' ResnetPointNet-based encoder network with two streams. The input point clouds are encoded with the same ResNet PointNet (shared weights) and the output codes are concatenated. Args: c_dim (int): dimension of latent code c dim (int): input points dimension hidden_dim (int): hidden dimension of the network ''' def __init__(self, c_dim=128, dim=3, hidden_dim=512, **kwargs): super().__init__() self.c_dim = int(c_dim / 2) self.resnet_pointnet = ResnetPointnet( self.c_dim, dim, hidden_dim, **kwargs) def forward(self, x): p_1 = x[:, 0] p_2 = x[:, 1] c_1 = self.resnet_pointnet(p_1) c_2 = self.resnet_pointnet(p_2) c = torch.cat([c_1, c_2], dim=-1) return c class TemporalResnetPointnet(nn.Module): ''' Temporal PointNet-based encoder network. The input point clouds are concatenated along the hidden dimension, e.g. for a sequence of length L, the dimension becomes 3xL = 51. Args: c_dim (int): dimension of latent code c dim (int): input points dimension hidden_dim (int): hidden dimension of the network use_only_first_pcl (bool): whether to use only the first point cloud ''' def __init__(self, c_dim=128, dim=51, hidden_dim=512, use_only_first_pcl=False, **kwargs): super().__init__() self.c_dim = c_dim self.use_only_first_pcl = use_only_first_pcl self.fc_pos = nn.Linear(dim, 2*hidden_dim) self.block_0 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_1 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_2 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_3 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.block_4 = ResnetBlockFC(2*hidden_dim, hidden_dim) self.fc_c = nn.Linear(hidden_dim, c_dim) self.actvn = nn.ReLU() self.pool = maxpool def forward(self, x): batch_size, n_steps, n_pts, _ = x.shape if len(x.shape) == 4 and self.use_only_first_pcl: x = x[:, 0] elif len(x.shape) == 4: x = x.transpose(1, 2).contiguous().view(batch_size, n_pts, -1) net = self.fc_pos(x) net = self.block_0(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_1(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_2(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_3(net) pooled = self.pool(net, dim=1, keepdim=True).expand(net.size()) net = torch.cat([net, pooled], dim=2) net = self.block_4(net) net = self.pool(net, dim=1) c = self.fc_c(self.actvn(net)) return c