modules/vision/pcd_openvocab_encoder.py

import os
import glob

import einops
import torch
import torch.nn as nn
import torch.nn.functional as F

from modules.build import VISION_REGISTRY
from modules.layers.pointnet import PointNetPP
from modules.layers.transformers import TransformerSpatialEncoderLayer
from modules.utils import get_mlp_head, layer_repeat, calc_pairwise_locs, get_mixup_function
from modules.weights import _init_weights_bert


@VISION_REGISTRY.register()
class PointOpenVocabEncoder(nn.Module):
    def __init__(self, cfg, backbone='pointnet++', hidden_size=768, path=None, freeze=False, dim_feedforward=2048,
                 num_attention_heads=12, spatial_dim=5, num_layers=4, dim_loc=6, pairwise_rel_type='center',
                 use_matmul_label=False, mixup_strategy=None, mixup_stage1=None, mixup_stage2=None,
                 lang_type='bert', lang_path=None, attn_type='spatial'):
        super().__init__()
        assert backbone in ['pointnet++']

        # build backbone
        if backbone == 'pointnet++':
            self.point_feature_extractor = PointNetPP(
                sa_n_points=[32, 16, None],
                sa_n_samples=[32, 32, None],
                sa_radii=[0.2, 0.4, None],
                sa_mlps=[[3, 64, 64, 128], [128, 128, 128, 256], [256, 256, 512, 768]],
            )
        elif backbone == 'pointnext':
            self.point_feature_extractor = PointNextEncoder(
                blocks=[1, 1, 1, 1, 1, 1],
                strides=[1, 2, 2, 2, 2, 1],
                sa_layers=2,
                sa_use_res=True,
                width=32,
                radius=0.15,
                radius_scaling=1.5,
                mlp_head=[1024, 768] if lang_type == 'bert' else []
            )

        # Open vocab grounding head
        vocab_file_name = f"scannet_607_{'bert-base-uncased' if lang_type == 'bert' else 'clip-ViT-B16'}_id.pth"
        self.register_buffer("text_features", torch.load(os.path.join(lang_path, vocab_file_name)))
        self.point_cls_head = lambda x: x @ self.text_features.t()
        self.dropout = nn.Dropout(0.1)

        self.attn_type = attn_type

        # freeze feature
        self.freeze = freeze
        if freeze:
            for p in self.parameters():
                p.requires_grad = False

        # build semantic cls embeds
        self.sem_cls_embed_layer = nn.Sequential(nn.Linear(hidden_size, hidden_size),
                                                 nn.LayerNorm(hidden_size),
                                                 nn.Dropout(0.1))

        # self.int2cat = json.load(
        #     open(os.path.join(glove_path, "annotations/meta_data/scannetv2_raw_categories.json"), 'r'))
        # self.cat2int = {w: i for i, w in enumerate(self.int2cat)}
        # self.cat2vec = json.load(open(os.path.join(glove_path, "annotations/meta_data/cat2glove42b.json"), 'r'))
        # self.register_buffer("int2mat", torch.ones(607, 300))
        # for i in range(607):
        #     self.int2mat[i, :] = torch.Tensor(self.cat2vec[self.int2cat[i]])

        self.use_matmul_label = use_matmul_label
        # build mask embedes
        self.sem_mask_embeddings = nn.Embedding(1, 768)

        # build spatial encoder layer
        if self.attn_type == 'spatial':
            pc_encoder_layer = TransformerSpatialEncoderLayer(hidden_size, num_attention_heads,
                                                              dim_feedforward=dim_feedforward,
                                                              dropout=0.1, activation='gelu',
                                                              spatial_dim=spatial_dim, spatial_multihead=True,
                                                              spatial_attn_fusion='cond')
            self.spatial_encoder = layer_repeat(pc_encoder_layer, num_layers)
            loc_layer = nn.Sequential(
                nn.Linear(dim_loc, hidden_size),
                nn.LayerNorm(hidden_size),
            )
            self.loc_layers = layer_repeat(loc_layer, 1)
            self.pairwise_rel_type = pairwise_rel_type
            self.spatial_dim = spatial_dim
        else:
            pass

        # # build mixup strategy
        # self.mixup_strategy = mixup_strategy
        # self.mixup_function = get_mixup_function(mixup_strategy, mixup_stage1, mixup_stage2)

        # load weights
        self.apply(_init_weights_bert)
        if path is not None:
            # pre_dict = {}
            # for name, p in self.named_parameters():
            #     pre_dict[name] = p
            # TODO: change this to accelerator loading multiple model files
            print("loaded")
            ckpts = glob.glob(os.path.join(path, '*.bin'))
            if len(ckpts) != 0:
                for ckpt in ckpts:
                    state_dict = torch.load(ckpt, map_location='cpu')
                    self.load_state_dict(state_dict, strict=False)
                print("loaded checkpoint files")
            elif path.endswith('.pth'):
                print("loaded checkpoint file")
                state_dict = torch.load(path)
                self.load_state_dict(state_dict, strict=False)
            # for name, p in self.named_parameters():
            #     if name in state_dict.keys():
            #         print(name, pre_dict[name] - layer_repeat(p, 1))
            # exit()

    def freeze_bn(self, m):
        for layer in m.modules():
            if isinstance(layer, nn.BatchNorm2d):
                layer.eval()

    def forward(self, obj_pcds, obj_locs, obj_masks, obj_sem_masks,
                obj_labels=None, cur_step=None, max_steps=None, **kwargs):
        if self.freeze:
            self.freeze_bn(self.point_feature_extractor)

        # get obj_embdes
        batch_size, num_objs, _, _ = obj_pcds.size()
        obj_embeds = self.point_feature_extractor(einops.rearrange(obj_pcds, 'b o p d -> (b o) p d'))
        # obj_sem_embeds = self.sem_cls_embed_layer(obj_embeds)
        # obj_sem_embeds = einops.rearrange(obj_sem_embeds, '(b o) d -> b o d', b=batch_size)
        obj_embeds = einops.rearrange(obj_embeds, '(b o) d -> b o d', b=batch_size)
        obj_embeds = self.dropout(obj_embeds)
        if self.freeze:
            obj_embeds = obj_embeds.detach()

        # get semantic cls embeds
        obj_sem_cls = F.softmax(self.point_cls_head(obj_embeds), dim=2).detach()

        # TODO: check if this sem_cls is still needed, switch this to cross attention
        # if self.mixup_strategy != None:
        #     obj_sem_cls_mix = self.mixup_function(obj_sem_cls, obj_labels, cur_step, max_steps)
        # else:
        #     obj_sem_cls_mix = obj_sem_cls
        # if self.use_matmul_label:
        #     obj_sem_cls_embeds = torch.matmul(obj_sem_cls_mix, self.int2mat)  # N, O, 607 matmul ,607, 300
        # else:
        #     obj_sem_cls_mix = torch.argmax(obj_sem_cls_mix, dim=2)
        #     obj_sem_cls_embeds = torch.Tensor(
        #         [self.cat2vec[self.int2cat[int(i)]] for i in obj_sem_cls_mix.view(batch_size * num_objs)])
        #     obj_sem_cls_embeds = obj_sem_cls_embeds.view(batch_size, num_objs, 300).cuda()
        # obj_sem_cls_embeds = self.sem_cls_embed_layer(obj_sem_cls_embeds)
        # obj_embeds = obj_embeds + obj_sem_embeds

        # # get semantic mask embeds
        # obj_embeds = obj_embeds.masked_fill(obj_sem_masks.unsqueeze(2).logical_not(), 0.0)
        # obj_sem_mask_embeds = self.sem_mask_embeddings(
        #     torch.zeros((batch_size, num_objs)).long().cuda()
        # ) * obj_sem_masks.logical_not().unsqueeze(2)
        # obj_embeds = obj_embeds + obj_sem_mask_embeds

        # record pre embedes
        # note: in our implementation, there are three types of embds, raw embeds from PointNet,
        # pre embeds after tokenization, post embeds after transformers
        obj_embeds_pre = obj_embeds

        # spatial reasoning, spatial attention transformer
        if self.attn_type == 'spatial':
            pairwise_locs = calc_pairwise_locs(obj_locs[:, :, :3], obj_locs[:, :, 3:],
                                               pairwise_rel_type=self.pairwise_rel_type, spatial_dist_norm=True,
                                               spatial_dim=self.spatial_dim)
            for i, pc_layer in enumerate(self.spatial_encoder):
                query_pos = self.loc_layers[0](obj_locs)
                obj_embeds = obj_embeds + query_pos
                obj_embeds, self_attn_matrices = pc_layer(obj_embeds, pairwise_locs,
                                                          tgt_key_padding_mask=obj_masks.logical_not())
        else:
            pass

        return obj_embeds, obj_embeds_pre, obj_sem_cls