| 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 |
|
|
