import torch from torch import Tensor from torch.cuda.amp import autocast from transformers import AutoModelForCausalLM, AutoModel, AutoTokenizer from model.build import MODEL_REGISTRY, BaseModel from modules.build import build_module from optim.utils import no_decay_param_group import torch.nn as nn def last_token_pool(last_hidden_states: Tensor, attention_mask: Tensor) -> Tensor: left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0]) if left_padding: return last_hidden_states[:, -1] else: sequence_lengths = attention_mask.sum(dim=1) - 1 batch_size = last_hidden_states.shape[0] return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), sequence_lengths] @MODEL_REGISTRY.register() class OpenVocab(BaseModel): def __init__(self, cfg): super().__init__(cfg) self.cfg = cfg model_root = "fg-clip-base" self.pm_encoder = AutoModelForCausalLM.from_pretrained(model_root, trust_remote_code=True) if cfg.mode in ['warmup', 'pretrain']: self.frozen_model = AutoModelForCausalLM.from_pretrained(model_root, trust_remote_code=True) self.use_scene_cap = self.cfg.data.args.get("use_scene_cap", False) self.set_training_mode() else: self.text_encoder = AutoModel.from_pretrained('jinaai/jina-clip-v2', trust_remote_code=True) self.tokenizer = AutoTokenizer.from_pretrained('jinaai/jina-clip-v2', trust_remote_code=True) self.text_encoder.text_model.output_tokens = True self.set_downstream_mode() self.head_list = self.cfg.model.heads.head_list for head in self.head_list: setattr(self, head, build_module("heads", getattr(self.cfg.model.heads, head))) def set_training_mode(self): for name, param in self.frozen_model.named_parameters(): param.requires_grad = False for name, param in self.pm_encoder.named_parameters(): if "text_model" in name: param.requires_grad = False self.pm_encoder.train() self.frozen_model.eval() def set_downstream_mode(self): """Set the model to downstream mode.""" for param in self.pm_encoder.parameters(): param.requires_grad = False for name, param in self.text_encoder.named_parameters(): if "vision_model" in name: param.requires_grad = False self.pm_encoder.eval() self.text_encoder.train() def forward(self, data_dict, mode=None): # Ensure step counters exist if 'cur_step' not in data_dict: data_dict['cur_step'] = 1 data_dict['total_steps'] = 1 data_dict['logit_scale'] = self.pm_encoder.logit_scale.exp() if mode == "warmup": B, C, H, W = data_dict["images"].shape data_dict["point_map"] = data_dict["point_map"].to(torch.bfloat16, non_blocking=True).permute(0, 3, 1, 2) data_dict["txt_ids"] = data_dict["txt_ids"].view(B, -1) with torch.autocast("cuda", dtype=torch.bfloat16): pm = data_dict["point_map"] _, data_dict["inter_view_pm_embed"] = self.pm_encoder.get_image_features(pm) with torch.no_grad(): data_dict["inter_view_txt_embed"] = self.frozen_model.get_text_features(data_dict["txt_ids"]) _, data_dict["inter_view_rgb_embed"] = self.frozen_model.get_image_features(data_dict["images"]) elif mode == 'pretrain': pm_basic_features = [] data_dict['point_map'] = data_dict['point_map'].to(torch.bfloat16, non_blocking=True).permute(0, 1, 4, 2, 3) for i in range(data_dict['point_map'].shape[0]): # batch dimension with autocast(dtype=torch.bfloat16): pm = data_dict['point_map'][i] # [8, C, H, W] _, pm_feat = self.pm_encoder.get_image_features(data_dict['point_map'][i]) pm_basic_features.append(pm_feat) data_dict['inter_view_pm_embed'] = torch.stack(pm_basic_features, dim=0) data_dict['scene_pm_embed'] = data_dict['inter_view_pm_embed'].mean(dim=1) B_txt = data_dict['txt_ids'].shape[0] lang_basic_features = torch.empty((B_txt, 32, 512), dtype=torch.bfloat16, device=data_dict['txt_ids'].device) rgb_basic_features = torch.empty((B_txt, 32, 512), dtype=torch.bfloat16, device=data_dict['txt_ids'].device) with torch.no_grad(): with autocast(dtype=torch.bfloat16): for i in range(B_txt): lang_basic_features[i] = self.frozen_model.get_text_features(data_dict['txt_ids'][i], walk_short_pos=True) rgb_basic_features[i] = self.frozen_model.get_image_features(data_dict['images'][i])[1] if getattr(self, "use_scene_cap", False): data_dict['scene_text_embed'] = self.frozen_model.get_text_features(data_dict['scene_txt_ids'], walk_short_pos=False) data_dict['inter_view_txt_embed'] = lang_basic_features data_dict['inter_view_rgb_embed'] = rgb_basic_features data_dict['scene_rgb_embed'] = rgb_basic_features.mean(dim=1) elif mode == 'qa': B, V, C, H, W = data_dict['point_map'].shape pm = data_dict['point_map'].reshape(B * V, C, H, W) with torch.no_grad(): with autocast(dtype=torch.bfloat16): _, pm_feats = self.pm_encoder.get_image_features(pm) data_dict['inter_view_pm_embed'] = pm_feats.reshape(B, V, -1) # jinaclip tokenized = self.tokenizer.batch_encode_plus( data_dict['sentence'], padding="max_length", return_tensors="pt", max_length=256, ).to(data_dict['inter_view_pm_embed'].device) # tokenized = self.tokenizer( # data_dict['sentence'], # padding=True, # max_length=256, # truncation = False, # return_tensors="pt", # ).to(data_dict['inter_view_pm_embed'].device) data_dict['txt_ids'] = tokenized['input_ids'] with autocast(dtype=torch.bfloat16): data_dict['inter_view_txt_tokens'] = self.text_encoder.text_model(data_dict['txt_ids'])[-1] data_dict['attention_mask'] = tokenized['attention_mask'].ne(1).bool() # text_embeddings = self.text_encoder(**tokenized) # data_dict['inter_view_txt_tokens'] = text_embeddings.last_hidden_state # --- QA Head (if used) --- if hasattr(self, "qa_head") and self.qa_head is not None: answer_scores = self.qa_head( data_dict['inter_view_pm_embed'], data_dict['inter_view_txt_tokens'], data_dict['attention_mask'] ) data_dict['answer_scores'] = answer_scores return data_dict def get_vision_params(self, model): return [(n, p) for n, p in model.named_parameters() if p.requires_grad] def get_text_params(self, model): text_params = [ (n, p) for n, p in model.named_parameters() if "text_model" in n ] return text_params def get_opt_params(self): def get_lr(cfg, default_lr): return default_lr if cfg.get("lr") is None else cfg.get("lr") optimizer_grouped_parameters = [] if self.cfg.mode == 'warmup': optimizer_grouped_parameters += no_decay_param_group(self.get_vision_params(self.pm_encoder),get_lr(self.cfg.model.vision, self.cfg.solver.lr)) elif self.cfg.mode == 'pretrain': optimizer_grouped_parameters += no_decay_param_group(self.get_vision_params(self.pm_encoder),get_lr(self.cfg.model.vision, self.cfg.solver.lr)) else: optimizer_grouped_parameters += no_decay_param_group(self.get_text_params(self.text_encoder), get_lr(self.cfg.model.vision, self.cfg.solver.lr)) if "qa_head" in self.head_list: optimizer_grouped_parameters += no_decay_param_group( self.qa_head.named_parameters(), get_lr(self.cfg.model.heads.qa_head, self.cfg.solver.lr) ) if "ground_head" in self.head_list: optimizer_grouped_parameters += no_decay_param_group( self.ground_head.named_parameters(), get_lr(self.cfg.model.heads.ground_head, self.cfg.solver.lr) ) return optimizer_grouped_parameters