import torch from torch import Tensor from torch.cuda.amp import autocast from transformers import AutoModelForCausalLM, AutoModel, AutoTokenizer, AutoImageProcessor from transformers.cache_utils import Cache, DynamicCache, SlidingWindowCache, StaticCache from transformers.modeling_rope_utils import ROPE_INIT_FUNCTIONS from model.build import MODEL_REGISTRY, BaseModel from modules.build import build_module from optim.utils import no_decay_param_group from peft import LoraConfig, get_peft_model from model.data_augmentation import * import torch.nn as nn from typing import List, Optional, Tuple, Union 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] class Qwen3RotaryEmbedding(nn.Module): def __init__( self, dim=None, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0, rope_type="default", ): super().__init__() self.rope_type = "default" self.max_seq_len_cached = 32768 self.original_max_seq_len = 32768 self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type] self.rope_kwargs = { "rope_type": rope_type, "factor": scaling_factor, "dim": 32, "base": base, "max_position_embeddings": max_position_embeddings, } inv_freq, self.attention_scaling = self.rope_init_fn(**self.rope_kwargs) self.register_buffer("inv_freq", inv_freq, persistent=False) self.original_inv_freq = self.inv_freq def _dynamic_frequency_update(self, position_ids, device): """ dynamic RoPE layers should recompute `inv_freq` in the following situations: 1 - growing beyond the cached sequence length (allow scaling) 2 - the current sequence length is in the original scale (avoid losing precision with small sequences) """ seq_len = torch.max(position_ids) + 1 if seq_len > self.max_seq_len_cached: # growth inv_freq, self.attention_scaling = self.rope_init_fn(**self.rope_kwargs) self.register_buffer("inv_freq", inv_freq, persistent=False) # TODO joao: may break with compilation self.max_seq_len_cached = seq_len if seq_len < self.original_max_seq_len and self.max_seq_len_cached > self.original_max_seq_len: # reset self.register_buffer("inv_freq", self.original_inv_freq, persistent=False) self.max_seq_len_cached = self.original_max_seq_len @torch.no_grad() def forward(self, x, position_ids): if "dynamic" in self.rope_type: self._dynamic_frequency_update(position_ids, device=x.device) # Core RoPE block inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1) position_ids_expanded = position_ids[:, None, :].float() # Force float32 (see https://github.com/huggingface/transformers/pull/29285) device_type = x.device.type device_type = device_type if isinstance(device_type, str) and device_type != "mps" else "cpu" with torch.autocast(device_type=device_type, enabled=False): freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2) emb = torch.cat((freqs, freqs), dim=-1) cos = emb.cos() sin = emb.sin() # Advanced RoPE types (e.g. yarn) apply a post-processing scaling factor, equivalent to scaling attention cos = cos * self.attention_scaling sin = sin * self.attention_scaling return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype) # Copied from transformers.models.llama.modeling_llama.rotate_half def rotate_half(x): """Rotates half the hidden dims of the input.""" x1 = x[..., : x.shape[-1] // 2] x2 = x[..., x.shape[-1] // 2:] return torch.cat((-x2, x1), dim=-1) # Copied from transformers.models.llama.modeling_llama.apply_rotary_pos_emb def apply_rotary_pos_emb(q, k, cos, sin, position_ids=None, unsqueeze_dim=1): """Applies Rotary Position Embedding to the query and key tensors. Args: q (`torch.Tensor`): The query tensor. k (`torch.Tensor`): The key tensor. cos (`torch.Tensor`): The cosine part of the rotary embedding. sin (`torch.Tensor`): The sine part of the rotary embedding. position_ids (`torch.Tensor`, *optional*): Deprecated and unused. unsqueeze_dim (`int`, *optional*, defaults to 1): The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2. Returns: `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding. """ cos = cos.unsqueeze(unsqueeze_dim) sin = sin.unsqueeze(unsqueeze_dim) q_embed = (q * cos) + (rotate_half(q) * sin) k_embed = (k * cos) + (rotate_half(k) * sin) return q_embed, k_embed class Qwen3RMSNorm(nn.Module): def __init__(self, hidden_size, eps=1e-6): """ Qwen3RMSNorm is equivalent to T5LayerNorm """ super().__init__() self.weight = nn.Parameter(torch.ones(hidden_size)) self.variance_epsilon = eps def forward(self, hidden_states): input_dtype = hidden_states.dtype hidden_states = hidden_states.to(torch.float32) variance = hidden_states.pow(2).mean(-1, keepdim=True) hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) return self.weight * hidden_states.to(input_dtype) def extra_repr(self): return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}" def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor: """ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch, num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim) """ batch, num_key_value_heads, slen, head_dim = hidden_states.shape if n_rep == 1: return hidden_states hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim) return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim) class Qwen3Attention(nn.Module): """ Multi-headed attention from 'Attention Is All You Need' paper. Modified to use sliding window attention: Longformer and "Generating Long Sequences with Sparse Transformers". """ def __init__(self, layer_idx = None): super().__init__() self.layer_idx = layer_idx if layer_idx is None: logger.warning_once( f"Instantiating {self.__class__.__name__} without passing `layer_idx` is not recommended and will " "to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` " "when creating this class." ) self.hidden_size = 512 self.num_heads = 16 self.head_dim = self.hidden_size // self.num_heads self.num_key_value_heads = 8 self.num_key_value_groups = self.num_heads // self.num_key_value_heads self.max_position_embeddings = 32768 self.rope_theta = 1000000 self.is_causal = True self.attention_dropout = 0.0 self.use_qk_norm = True self.headwise_attn_output_gate = False self.elementwise_attn_output_gate = True qkv_bias = False rms_norm_eps = 1e-06 if self.headwise_attn_output_gate: self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim + self.num_heads, bias=qkv_bias) elif self.elementwise_attn_output_gate: self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim * 2, bias=qkv_bias) else: self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=qkv_bias) self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=qkv_bias) self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=qkv_bias) self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=qkv_bias) if self.use_qk_norm: self.q_norm = Qwen3RMSNorm(self.head_dim, eps=rms_norm_eps) self.k_norm = Qwen3RMSNorm(self.head_dim, eps=rms_norm_eps) def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, past_key_value: Optional[Cache] = None, output_attentions: bool = False, use_cache: bool = False, cache_position: Optional[torch.LongTensor] = None, position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, # necessary, but kept here for BC ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: bsz, q_len, _ = hidden_states.size() query_states = self.q_proj(hidden_states) key_states = self.k_proj(hidden_states) value_states = self.v_proj(hidden_states) if self.headwise_attn_output_gate: query_states = query_states.view(bsz, q_len, self.num_key_value_heads, -1) query_states, gate_score = torch.split(query_states, [self.head_dim * self.num_key_value_groups, self.num_key_value_groups], dim=-1) gate_score = gate_score.reshape(bsz, q_len, -1, 1) query_states = query_states.reshape(bsz, q_len, -1, self.head_dim).transpose(1, 2) elif self.elementwise_attn_output_gate: query_states = query_states.view(bsz, q_len, self.num_key_value_heads, -1) query_states, gate_score = torch.split(query_states, [self.head_dim * self.num_key_value_groups, self.head_dim * self.num_key_value_groups], dim=-1) gate_score = gate_score.reshape(bsz, q_len, -1, self.head_dim) query_states = query_states.reshape(bsz, q_len, -1, self.head_dim).transpose(1, 2) else: query_states = query_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2) key_states = key_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2) value_states = value_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2) if self.use_qk_norm: query_states = self.q_norm(query_states) key_states = self.k_norm(key_states) cos, sin = position_embeddings query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin) if past_key_value is not None: cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position} # Specific to RoPE models key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs) # repeat k/v heads if n_kv_heads < n_heads key_states = repeat_kv(key_states, self.num_key_value_groups) value_states = repeat_kv(value_states, self.num_key_value_groups) attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim) if attention_mask is not None: # no matter the length, we just slice it causal_mask = attention_mask[:, :, :, : key_states.shape[-2]] attn_weights = attn_weights + causal_mask # upcast attention to fp32 attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype) attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training) attn_output = torch.matmul(attn_weights, value_states) if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim): raise ValueError( f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is" f" {attn_output.size()}" ) attn_output = attn_output.transpose(1, 2).contiguous() if self.headwise_attn_output_gate or self.elementwise_attn_output_gate: attn_output = attn_output * torch.sigmoid(gate_score) attn_output = attn_output.reshape(bsz, q_len, -1) attn_output = self.o_proj(attn_output) if not output_attentions: attn_weights = None return attn_output class _GlobalViewAttnBlock(nn.Module): """One pre-norm Transformer-style block over view tokens (B,V,D).""" def __init__( self, dim: int, num_heads: int, mlp_ratio: float, dropout: float, zero_init_residual: bool, zero_init_attn_out: bool, ): super().__init__() self.zero_init_residual = zero_init_residual self.zero_init_attn_out = zero_init_attn_out self.norm1 = nn.LayerNorm(dim) self.attn = nn.MultiheadAttention( embed_dim=dim, num_heads=num_heads, dropout=dropout, batch_first=True, bias=True, ) self.norm2 = nn.LayerNorm(dim) hidden_dim = int(dim * mlp_ratio) self.mlp = nn.Sequential( nn.Linear(dim, hidden_dim), nn.GELU(), nn.Dropout(dropout), nn.Linear(hidden_dim, dim), nn.Dropout(dropout), ) self._init_weights() def forward(self, x, key_padding_mask=None): h = self.norm1(x) attn_out, _ = self.attn( h, h, h, key_padding_mask=key_padding_mask, need_weights=False, ) x = x + attn_out x = x + self.mlp(self.norm2(x)) return x @torch.no_grad() def _init_weights(self): # LayerNorm for ln in (self.norm1, self.norm2): nn.init.ones_(ln.weight) nn.init.zeros_(ln.bias) # MultiheadAttention: in_proj for qkv (3D, D) if getattr(self.attn, "in_proj_weight", None) is not None: nn.init.xavier_uniform_(self.attn.in_proj_weight) if getattr(self.attn, "in_proj_bias", None) is not None: nn.init.zeros_(self.attn.in_proj_bias) # out proj nn.init.xavier_uniform_(self.attn.out_proj.weight) if self.attn.out_proj.bias is not None: nn.init.zeros_(self.attn.out_proj.bias) # optional: start attn residual near-zero if self.zero_init_attn_out: nn.init.zeros_(self.attn.out_proj.weight) if self.attn.out_proj.bias is not None: nn.init.zeros_(self.attn.out_proj.bias) # MLP fc1: nn.Linear = self.mlp[0] fc2: nn.Linear = self.mlp[3] nn.init.xavier_uniform_(fc1.weight) if fc1.bias is not None: nn.init.zeros_(fc1.bias) # zero-init last projection for stable residual start (recommended) if self.zero_init_residual: nn.init.zeros_(fc2.weight) if fc2.bias is not None: nn.init.zeros_(fc2.bias) else: nn.init.xavier_uniform_(fc2.weight) if fc2.bias is not None: nn.init.zeros_(fc2.bias) class _GlobalViewGatedAttnBlock(nn.Module): """Pre-norm Transformer block over view tokens (B,V,D) with gated residuals.""" def __init__( self, dim: int, num_heads: int, mlp_ratio: float, dropout: float, zero_init_residual: bool, zero_init_attn_out: bool, gate_bias_init: float = -2.0, # sigmoid(-2)≈0.12, starts near-identity (small updates) ): super().__init__() self.zero_init_residual = zero_init_residual self.zero_init_attn_out = zero_init_attn_out self.norm1 = nn.LayerNorm(dim) self.attn = nn.MultiheadAttention( embed_dim=dim, num_heads=num_heads, dropout=dropout, batch_first=True, bias=True, ) # --- Gating for attention residual --- # Produces per-token, per-channel gates in (0,1) self.attn_gate = nn.Linear(dim, dim, bias=True) self.norm2 = nn.LayerNorm(dim) hidden_dim = int(dim * mlp_ratio) self.mlp = nn.Sequential( nn.Linear(dim, hidden_dim), nn.GELU(), nn.Dropout(dropout), nn.Linear(hidden_dim, dim), nn.Dropout(dropout), ) # --- Gating for MLP residual --- self.mlp_gate = nn.Linear(dim, dim, bias=True) self._init_weights(gate_bias_init=gate_bias_init) def forward(self, x: torch.Tensor, key_padding_mask=None) -> torch.Tensor: # x: (B, V, D) h1 = self.norm1(x) attn_out, _ = self.attn( h1, h1, h1, key_padding_mask=key_padding_mask, need_weights=False, ) g_attn = torch.sigmoid(self.attn_gate(h1)) # (B, V, D) x = x + g_attn * attn_out h2 = self.norm2(x) mlp_out = self.mlp(h2) g_mlp = torch.sigmoid(self.mlp_gate(h2)) # (B, V, D) x = x + g_mlp * mlp_out return x @torch.no_grad() def _init_weights(self, gate_bias_init: float): # LayerNorm for ln in (self.norm1, self.norm2): nn.init.ones_(ln.weight) nn.init.zeros_(ln.bias) # MultiheadAttention: in_proj for qkv if getattr(self.attn, "in_proj_weight", None) is not None: nn.init.xavier_uniform_(self.attn.in_proj_weight) if getattr(self.attn, "in_proj_bias", None) is not None: nn.init.zeros_(self.attn.in_proj_bias) # out proj nn.init.xavier_uniform_(self.attn.out_proj.weight) if self.attn.out_proj.bias is not None: nn.init.zeros_(self.attn.out_proj.bias) # optional: start attn residual near-zero if self.zero_init_attn_out: nn.init.zeros_(self.attn.out_proj.weight) if self.attn.out_proj.bias is not None: nn.init.zeros_(self.attn.out_proj.bias) # MLP fc1: nn.Linear = self.mlp[0] fc2: nn.Linear = self.mlp[3] nn.init.xavier_uniform_(fc1.weight) if fc1.bias is not None: nn.init.zeros_(fc1.bias) if self.zero_init_residual: nn.init.zeros_(fc2.weight) if fc2.bias is not None: nn.init.zeros_(fc2.bias) else: nn.init.xavier_uniform_(fc2.weight) if fc2.bias is not None: nn.init.zeros_(fc2.bias) # Gates: start “mostly closed” so training is stable, then learn to open nn.init.zeros_(self.attn_gate.weight) nn.init.constant_(self.attn_gate.bias, gate_bias_init) nn.init.zeros_(self.mlp_gate.weight) nn.init.constant_(self.mlp_gate.bias, gate_bias_init) class GlobalViewAttention(nn.Module): """ Multi-layer global self-attention over multi-view tokens. Input: x ∈ (B, V, D) Output: x' ∈ (B, V, D) """ def __init__( self, dim: int, num_layers: int = 1, num_heads: int = 8, mlp_ratio: float = 4.0, dropout: float = 0.0, zero_init_residual: bool = True, # recommended (stable when adding layers) zero_init_attn_out: bool = False, # optional extra safety ): super().__init__() assert num_layers >= 1, "num_layers must be >= 1" self.dim = dim self.num_layers = num_layers self.num_heads = num_heads # self.layers = nn.ModuleList([Qwen3Attention(layer_idx) for layer_idx in range(num_layers)]) # self.rotary_emb = Qwen3RotaryEmbedding() self.layers = nn.ModuleList([ _GlobalViewAttnBlock( dim=dim, num_heads=num_heads, mlp_ratio=mlp_ratio, dropout=dropout, zero_init_residual=zero_init_residual, zero_init_attn_out=zero_init_attn_out, ) for _ in range(num_layers) ]) def forward(self, x, key_padding_mask=None): """ x: (B, V, D) key_padding_mask: (B, V), True = ignore (padding) """ for layer in self.layers: x = layer(x, key_padding_mask=key_padding_mask) return x @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) # self.global_attn = GlobalViewAttention(dim=512, num_heads=8, mlp_ratio=4.0, dropout=0.1) 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": data_dict['images'] = data_dict['images'].squeeze(1) data_dict['point_map'] = data_dict['point_map'].squeeze(1).permute(0, 3, 1, 2) B, C, H, W = data_dict["images"].shape 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 = [] B, V, H, W, C = data_dict['point_map'].shape # point_cloud = data_dict['point_map'].reshape(B, -1, C).contiguous() # point_cloud, _ = scale_point_cloud(point_cloud, min_s=0.8, max_s=1.2) # point_cloud, _ = rotate_point_cloud(point_cloud) # point_cloud, _ = translate_point_cloud(point_cloud, scale=0.1) # point_cloud, _ = rotate_point_cloud_z(point_cloud) # point_maps = point_cloud.reshape(B, V, H, W, C) # data_dict['point_map'] = point_cloud.reshape(B, V, H, W, C).to(torch.bfloat16, non_blocking=True).permute(0, 1, 4, 2, 3) 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) pm_basic_features = torch.stack(pm_basic_features, dim=0) data_dict['inter_view_pm_embed'] = pm_basic_features # with autocast(dtype=torch.bfloat16): # pm_basic_features = self.global_attn(pm_basic_features) # data_dict['inter_view_context_pm_embed'] = pm_basic_features # data_dict['scene_pm_embed'] = data_dict['inter_view_context_pm_embed'].mean(dim=1) 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) ground_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) ground_lang_basic_features[i] = self.frozen_model.get_text_features(data_dict['ground_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_ground_txt_embed'] = ground_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 B, V, C, H, W = data_dict['vision_inputs'].shape vision_inputs = data_dict['vision_inputs'].reshape(B * V, C, H, W).contiguous().float() with torch.no_grad(): with autocast(dtype=torch.bfloat16): _, vision_feat = self.pm_encoder.get_image_features(vision_inputs) data_dict['inter_view_pm_embed'] = vision_feat.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)) # optimizer_grouped_parameters += no_decay_param_group(self.get_vision_params(self.global_attn), 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