|
|
import torch |
|
|
import torch.nn as nn |
|
|
import json |
|
|
from pathlib import Path |
|
|
|
|
|
import clip |
|
|
from transformers import BertConfig, BertModel, BertTokenizer |
|
|
from einops import rearrange |
|
|
|
|
|
from model.build import MODEL_REGISTRY, BaseModel |
|
|
from modules.layers.pointnet import PointNetPP |
|
|
from modules.utils import get_mlp_head |
|
|
from optim.utils import no_decay_param_group |
|
|
|
|
|
|
|
|
@MODEL_REGISTRY.register() |
|
|
class ObjCls(BaseModel): |
|
|
def __init__(self, cfg): |
|
|
super().__init__(cfg) |
|
|
self.cfg = cfg |
|
|
self.model_name = cfg.model.get("model_name", "pointnext") |
|
|
self.language_type = cfg.model.get("language_type", "clip") |
|
|
self.pre_extract_path = cfg.model.get("pre_extract_path", None) |
|
|
|
|
|
cls_in_channel = 512 if self.language_type == "clip" else 768 |
|
|
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, cls_in_channel]], |
|
|
) |
|
|
|
|
|
if cfg.num_gpu > 1: |
|
|
self.point_feature_extractor = torch.nn.SyncBatchNorm.convert_sync_batchnorm(self.point_feature_extractor) |
|
|
|
|
|
if not cfg.model.open_vocab: |
|
|
cls_hidden = cfg.model.get("cls_hidden", 1024) |
|
|
num_classes = cfg.model.num_classes |
|
|
self.cls_head = get_mlp_head(cls_in_channel, cls_hidden, num_classes) |
|
|
else: |
|
|
if self.pre_extract_path is not None: |
|
|
file_name = f"scannet_607_{'clip-ViT-B16' if self.language_type == 'clip' else 'bert-base-uncased'}_id.pth" |
|
|
self.register_buffer("text_embeds", torch.load(Path(self.pre_extract_path) / file_name).float()) |
|
|
else: |
|
|
self.int2cat = json.load(open(cfg.model.vocab_path, "r")) |
|
|
if self.language_type == "clip": |
|
|
self.clip_head = clip.load("ViT-B/16") |
|
|
self.text_embeds = self.clip_head.encode_text(clip.tokenize(self.int2cat)).detach() |
|
|
elif self.language_type == "bert": |
|
|
self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased", do_lower_case=True) |
|
|
self.bert_config = BertConfig( |
|
|
hidden_size=768, num_hidden_layers=3, num_attention=12, type_vocab_size=2 |
|
|
) |
|
|
self.model = BertModel.from_pretrained("bert-base-uncased", config=self.bert_config) |
|
|
self.encoded_input = self.tokenizer( |
|
|
self.int2cat, padding=True, truncation=True, add_special_tokens=True, return_tensors="pt" |
|
|
) |
|
|
self.text_embeds = self.model(**self.encoded_input).last_hidden_state |
|
|
self.text_embeds = self.text_embeds.detach() |
|
|
else: |
|
|
raise NotImplementedError |
|
|
self.dropout = nn.Dropout(0.1) |
|
|
|
|
|
def forward(self, data_dict): |
|
|
|
|
|
if 'cur_step' not in data_dict.keys(): |
|
|
data_dict['cur_step'] = 1 |
|
|
data_dict['total_steps'] = 1 |
|
|
|
|
|
obj_pcds = data_dict["obj_fts"] |
|
|
batch_size, num_objs, _, _ = obj_pcds.size() |
|
|
if self.model_name == "pointnext": |
|
|
obj_locs = rearrange(obj_pcds[..., :3], 'b o p d -> (b o) p d') |
|
|
obj_fts = rearrange(obj_pcds[..., 3:], 'b o p d -> (b o) d p').contiguous() |
|
|
obj_embeds = self.point_feature_extractor(obj_locs, obj_fts, type="cls") |
|
|
elif self.model_name == "pointnet++": |
|
|
obj_pcds = rearrange(obj_pcds, 'b o p d -> (b o) p d') |
|
|
obj_embeds = self.point_feature_extractor(obj_pcds) |
|
|
elif self.model_name == "pointmlp": |
|
|
obj_pcds = rearrange(obj_pcds, 'b o p d -> (b o) p d') |
|
|
obj_embeds = self.point_feature_extractor(obj_pcds) |
|
|
obj_embeds = self.dropout(obj_embeds) |
|
|
if self.cfg.model.open_vocab: |
|
|
logits = obj_embeds @ self.text_embeds.t() |
|
|
data_dict["obj_logits"] = rearrange(logits, '(b o) c -> b o c', b=batch_size) |
|
|
else: |
|
|
data_dict["obj_logits"] = rearrange(self.cls_head(obj_embeds), '(b o) d -> b o d', b=batch_size) |
|
|
return data_dict |
|
|
|
|
|
def get_opt_params(self): |
|
|
optimizer_grouped_parameters = [] |
|
|
optimizer_grouped_parameters.append({ |
|
|
"params": self.parameters(), |
|
|
"weight_decay": self.cfg.solver.get("weight_decay", 0.0), |
|
|
"lr": self.cfg.solver.lr |
|
|
}) |
|
|
return optimizer_grouped_parameters |
|
|
|
