| import torch | |
| import torch.nn as nn | |
| import json | |
| import torch.nn.functional as F | |
| from optim.loss.loss import LOSS_REGISTRY | |
| try: | |
| import torch.distributed.nn | |
| from torch import distributed as dist | |
| has_distributed = True | |
| except ImportError: | |
| has_distributed = False | |
| try: | |
| import horovod.torch as hvd | |
| except ImportError: | |
| hvd = None | |
| def load_json(path): | |
| with open(path, 'r') as f: | |
| return json.load(f) | |
| def gather_features( | |
| image_features, | |
| text_features, | |
| local_loss=False, | |
| gather_with_grad=False, | |
| rank=0, | |
| world_size=1, | |
| use_horovod=False | |
| ): | |
| assert has_distributed, 'torch.distributed did not import correctly, please use a PyTorch version with support.' | |
| if use_horovod: | |
| assert hvd is not None, 'Please install horovod' | |
| if gather_with_grad: | |
| all_image_features = hvd.allgather(image_features) | |
| all_text_features = hvd.allgather(text_features) | |
| else: | |
| with torch.no_grad(): | |
| all_image_features = hvd.allgather(image_features) | |
| all_text_features = hvd.allgather(text_features) | |
| if not local_loss: | |
| # ensure grads for local rank when all_* features don't have a gradient | |
| gathered_image_features = list(all_image_features.chunk(world_size, dim=0)) | |
| gathered_text_features = list(all_text_features.chunk(world_size, dim=0)) | |
| gathered_image_features[rank] = image_features | |
| gathered_text_features[rank] = text_features | |
| all_image_features = torch.cat(gathered_image_features, dim=0) | |
| all_text_features = torch.cat(gathered_text_features, dim=0) | |
| else: | |
| # We gather tensors from all gpus | |
| if gather_with_grad: | |
| all_image_features = torch.cat(torch.distributed.nn.all_gather(image_features), dim=0) | |
| all_text_features = torch.cat(torch.distributed.nn.all_gather(text_features), dim=0) | |
| else: | |
| gathered_image_features = [torch.zeros_like(image_features) for _ in range(world_size)] | |
| gathered_text_features = [torch.zeros_like(text_features) for _ in range(world_size)] | |
| dist.all_gather(gathered_image_features, image_features) | |
| dist.all_gather(gathered_text_features, text_features) | |
| if not local_loss: | |
| # ensure grads for local rank when all_* features don't have a gradient | |
| gathered_image_features[rank] = image_features | |
| gathered_text_features[rank] = text_features | |
| all_image_features = torch.cat(gathered_image_features, dim=0) | |
| all_text_features = torch.cat(gathered_text_features, dim=0) | |
| return all_image_features, all_text_features | |
| class ClipLoss(nn.Module): | |
| def __init__( | |
| self, | |
| local_loss=False, | |
| gather_with_grad=False, | |
| cache_labels=False, | |
| rank=0, | |
| world_size=1, | |
| use_horovod=False, | |
| ): | |
| super().__init__() | |
| self.local_loss = local_loss | |
| self.gather_with_grad = gather_with_grad | |
| self.cache_labels = cache_labels | |
| self.rank = rank | |
| self.world_size = world_size | |
| self.use_horovod = use_horovod | |
| # cache state | |
| self.prev_num_logits = 0 | |
| self.labels = {} | |
| def get_ground_truth(self, device, num_logits) -> torch.Tensor: | |
| # calculated ground-truth and cache if enabled | |
| if self.prev_num_logits != num_logits or device not in self.labels: | |
| labels = torch.arange(num_logits, device=device, dtype=torch.long) | |
| if self.world_size > 1 and self.local_loss: | |
| labels = labels + num_logits * self.rank | |
| if self.cache_labels: | |
| self.labels[device] = labels | |
| self.prev_num_logits = num_logits | |
| else: | |
| labels = self.labels[device] | |
| return labels | |
| def get_logits(self, image_features, text_features, logit_scale, logit_bias=None): | |
| if self.world_size > 1: | |
| all_image_features, all_text_features = gather_features( | |
| image_features, | |
| text_features, | |
| local_loss=self.local_loss, | |
| gather_with_grad=self.gather_with_grad, | |
| rank=self.rank, | |
| world_size=self.world_size, | |
| use_horovod=self.use_horovod, | |
| ) | |
| if self.local_loss: | |
| logits_per_image = logit_scale * image_features @ all_text_features.T | |
| logits_per_text = logit_scale * text_features @ all_image_features.T | |
| else: | |
| logits_per_image = logit_scale * all_image_features @ all_text_features.T | |
| logits_per_text = logits_per_image.T | |
| else: | |
| logits_per_image = logit_scale * image_features @ text_features.T | |
| logits_per_text = logit_scale * text_features @ image_features.T | |
| if logit_bias is not None: | |
| logits_per_image += logit_bias | |
| logits_per_text += logit_bias | |
| return logits_per_image, logits_per_text | |
| def forward( | |
| self, | |
| image_features, | |
| text_features, | |
| logit_scale, | |
| logit_bias=None, | |
| output_dict=False, | |
| bidirectional = True | |
| ): | |
| device = image_features.device | |
| logits_per_image, logits_per_text = self.get_logits( | |
| image_features, | |
| text_features, | |
| logit_scale, | |
| logit_bias=logit_bias, | |
| ) | |
| labels = self.get_ground_truth(device, logits_per_image.shape[0]) | |
| if bidirectional: | |
| total_loss = ( | |
| F.cross_entropy(logits_per_image, labels) + | |
| F.cross_entropy(logits_per_text, labels) | |
| ) / 2 | |
| else: | |
| total_loss = F.cross_entropy(logits_per_image, labels) | |
| return {"contrastive_loss": total_loss} if output_dict else total_loss | |
| def soft_targets_from_dist(dist_bvv: torch.Tensor, tau_d: float, eye: torch.Tensor, eps=1e-8): | |
| """ | |
| dist_bvv: (B,V,V) distances (>=0). Smaller = closer. | |
| eye: (V,V) bool diagonal mask | |
| returns: (B,V,V) row-stochastic soft targets, diag=0 | |
| """ | |
| # mask diagonal by setting huge distance (or directly zero later) | |
| dist = dist_bvv.masked_fill(eye.unsqueeze(0), float("inf")) | |
| # logits for target distribution (higher for closer) | |
| tgt_logits = -dist / tau_d | |
| tgt_logits = tgt_logits.masked_fill(eye.unsqueeze(0), -1e9) | |
| p = torch.softmax(tgt_logits, dim=-1) # (B,V,V) | |
| # numerical safety: ensure diag is exactly 0 then renormalize | |
| p = p.masked_fill(eye.unsqueeze(0), 0.0) | |
| p = p / (p.sum(dim=-1, keepdim=True) + eps) | |
| return p | |
| def soft_ce_from_logits(logits_bvv: torch.Tensor, p_bvv: torch.Tensor, eye: torch.Tensor): | |
| """ | |
| logits_bvv: (B,V,V) predicted logits | |
| p_bvv: (B,V,V) soft targets (row-stochastic) | |
| """ | |
| log_q = F.log_softmax(logits_bvv, dim=-1) # (B,V,V) | |
| # cross-entropy with soft labels: -sum p * log q | |
| loss = -(p_bvv * log_q).sum(dim=-1) # (B,V) | |
| return loss.mean() | |
| class WarmUpPM_loss(nn.Module): | |
| def __init__(self, cfg, accelerator): | |
| super().__init__() | |
| self.accelerator = accelerator | |
| self.temperature = getattr(cfg, "contrastive_temperature", 1.0) | |
| self.num_gpu = cfg.num_gpu | |
| world_sz = self.accelerator.num_processes | |
| rank = self.accelerator.process_index | |
| self.contrast_loss = ClipLoss(rank=rank, world_size=world_sz) | |
| def forward(self, data_dict): | |
| logit_scale = data_dict['logit_scale'] | |
| view_rgb = data_dict['inter_view_rgb_embed'] # (B,V,D) | |
| view_txt = data_dict['inter_view_txt_embed'] # (B,V,D) | |
| view_pm = data_dict['inter_view_pm_embed'] # (B,V,D) | |
| view_pm = F.normalize(view_pm, p=2, dim=1) | |
| view_rgb = F.normalize(view_rgb, p=2, dim=1) | |
| view_txt = F.normalize(view_txt, p=2, dim=1) | |
| loss_rgb_pm_view = self.contrast_loss(view_pm, view_rgb, logit_scale) | |
| loss_txt_pm_view = self.contrast_loss(view_pm, view_txt, logit_scale) | |
| return { | |
| 'loss_rgb_pm_view': loss_rgb_pm_view, | |
| 'loss_txt_pm_view': loss_txt_pm_view | |
| } | |
| # @LOSS_REGISTRY.register() | |
| # class SceneViewPM_loss(nn.Module): | |
| # def __init__(self, cfg, accelerator): | |
| # super().__init__() | |
| # self.accelerator = accelerator | |
| # world_sz = self.accelerator.num_processes | |
| # rank = self.accelerator.process_index | |
| # self.contrast_loss = ClipLoss(rank=rank, world_size=world_sz) | |
| # self.chamfer_ranking = load_json( | |
| # "/home/m50048399/transfered/ye_project/Project2/chamfer_rankings.json" | |
| # ) | |
| # # Cache: (scan_id, V) -> pos_idx_cpu: LongTensor[V] (CPU) | |
| # self._pos_idx_cache = {} | |
| # # Per-scan caches | |
| # self._view_keys_cache = {} # scan_id -> List[str] sorted view keys | |
| # self._first_pos_cache = {} # scan_id -> Dict[str, Optional[str]] first non-self neighbor (string) | |
| # # Cache diagonal masks per (V, device) | |
| # self._eye_mask_cache = {} # (V, device) -> BoolTensor[V,V] | |
| # self._dbg_every = int(getattr(cfg, "dbg_every", 10)) if cfg is not None else 10 | |
| # self._dbg_step = 0 | |
| # # ------------------------- | |
| # # Small helper: cached diag mask | |
| # # ------------------------- | |
| # def _get_eye_mask(self, V: int, device: torch.device): | |
| # key = (V, device) | |
| # m = self._eye_mask_cache.get(key, None) | |
| # if m is None: | |
| # m = torch.eye(V, dtype=torch.bool, device=device) | |
| # self._eye_mask_cache[key] = m | |
| # return m | |
| # # ------------------------- | |
| # # Per-scan cache build | |
| # # ------------------------- | |
| # def _ensure_scan_cached(self, scan_id: str): | |
| # scan_id = str(scan_id) | |
| # if scan_id in self._view_keys_cache and scan_id in self._first_pos_cache: | |
| # return | |
| # rank_dict = self.chamfer_ranking[scan_id] # {view_key: [neighbors...]} | |
| # # Normalize keys to str once (neighbors are accessed lazily) | |
| # keys = [str(k) for k in rank_dict.keys()] | |
| # try: | |
| # keys_sorted = sorted(keys, key=lambda x: int(x)) | |
| # except Exception: | |
| # keys_sorted = keys | |
| # # Precompute first non-self neighbor per key (as str) | |
| # first_pos = {} | |
| # for k in keys_sorted: | |
| # cands = rank_dict[k] if k in rank_dict else rank_dict[int(k)] # tolerate int keys if present | |
| # fp = None | |
| # ks = str(k) | |
| # for v in cands: | |
| # vs = str(v) | |
| # if vs != ks: | |
| # fp = vs | |
| # break | |
| # first_pos[ks] = fp | |
| # self._view_keys_cache[scan_id] = keys_sorted | |
| # self._first_pos_cache[scan_id] = first_pos | |
| # def _get_view_keys(self, scan_id): | |
| # scan_id = str(scan_id) | |
| # vk = self._view_keys_cache.get(scan_id, None) | |
| # if vk is not None: | |
| # return vk | |
| # self._ensure_scan_cached(scan_id) | |
| # return self._view_keys_cache[scan_id] | |
| # def soft_targets_from_dist(dist_bvv: torch.Tensor, tau_d: float, eye: torch.Tensor, eps=1e-8): | |
| # """ | |
| # dist_bvv: (B,V,V) distances (>=0). Smaller = closer. | |
| # eye: (V,V) bool diagonal mask | |
| # returns: (B,V,V) row-stochastic soft targets, diag=0 | |
| # """ | |
| # # mask diagonal by setting huge distance (or directly zero later) | |
| # dist = dist_bvv.masked_fill(eye.unsqueeze(0), float("inf")) | |
| # # logits for target distribution (higher for closer) | |
| # tgt_logits = -dist / tau_d | |
| # tgt_logits = tgt_logits.masked_fill(eye.unsqueeze(0), -1e9) | |
| # p = torch.softmax(tgt_logits, dim=-1) # (B,V,V) | |
| # # numerical safety: ensure diag is exactly 0 then renormalize | |
| # p = p.masked_fill(eye.unsqueeze(0), 0.0) | |
| # p = p / (p.sum(dim=-1, keepdim=True) + eps) | |
| # return p | |
| # @torch.no_grad() | |
| # def _get_pos_idx_cpu(self, scan_id: str, V: int) -> torch.LongTensor: | |
| # """ | |
| # CPU LongTensor [V], where pos_idx[i] is index of closest *other* view for view i. | |
| # Cached per (scan_id, V). | |
| # """ | |
| # scan_id = str(scan_id) | |
| # key = (scan_id, V) | |
| # cached = self._pos_idx_cache.get(key, None) | |
| # if cached is not None: | |
| # return cached | |
| # self._ensure_scan_cached(scan_id) | |
| # view_keys = self._view_keys_cache[scan_id][:V] | |
| # key2pos = {k: i for i, k in enumerate(view_keys)} # O(V) | |
| # first_pos = self._first_pos_cache[scan_id] | |
| # pos_idx = [0] * V | |
| # for i, cur in enumerate(view_keys): | |
| # cur = str(cur) | |
| # pv = first_pos.get(cur, None) # already first non-self neighbor | |
| # if pv is None or pv not in key2pos: | |
| # pos_idx[i] = (i + 1) % V | |
| # else: | |
| # pos_idx[i] = key2pos[pv] | |
| # out = torch.tensor(pos_idx, dtype=torch.long, device="cpu") | |
| # self._pos_idx_cache[key] = out | |
| # return out | |
| # def forward(self, data_dict): | |
| # scan_ids = list(data_dict["scan_id"]) | |
| # logit_scale = data_dict["logit_scale"] | |
| # view_rgb = data_dict["inter_view_rgb_embed"] # (B,V,D) | |
| # view_txt = data_dict["inter_view_txt_embed"] # (B,V,D) | |
| # view_pm = data_dict["inter_view_pm_embed"] # (B,V,D) | |
| # scene_rgb = data_dict["scene_rgb_embed"] # (B,D) | |
| # scene_txt = data_dict["scene_text_embed"] # (B,D) | |
| # scene_pm = data_dict["scene_pm_embed"] # (B,D) | |
| # B, V, D = view_pm.shape | |
| # device = view_pm.device | |
| # # ---- Normalize ---- | |
| # view_pm_norm = F.normalize(view_pm, p=2, dim=-1) # (B,V,D) | |
| # view_rgb_norm = F.normalize(view_rgb, p=2, dim=-1) # (B,V,D) | |
| # view_txt_norm = F.normalize(view_txt, p=2, dim=-1) # (B,V,D) | |
| # view_pm_f = view_pm_norm.reshape(-1, D) # (B*V,D) | |
| # view_rgb_f = view_rgb_norm.reshape(-1, D) | |
| # view_txt_f = view_txt_norm.reshape(-1, D) | |
| # scene_rgb = F.normalize(scene_rgb, p=2, dim=-1) | |
| # scene_txt = F.normalize(scene_txt, p=2, dim=-1) | |
| # scene_pm = F.normalize(scene_pm, p=2, dim=-1) | |
| # # temperature safety | |
| # if torch.is_tensor(logit_scale): | |
| # logit_scale = logit_scale.clamp(max=100) | |
| # # ---- Cross-modal CLIP losses (unchanged) ---- | |
| # loss_rgb_pm_view = self.contrast_loss(view_pm_f, view_rgb_f, logit_scale) | |
| # loss_txt_pm_view = self.contrast_loss(view_pm_f, view_txt_f, logit_scale) | |
| # loss_rgb_pm_scene = self.contrast_loss(scene_pm, scene_rgb, logit_scale) | |
| # loss_txt_pm_scene = self.contrast_loss(scene_pm, scene_txt, logit_scale) | |
| # # ---- Targets: nearest neighbor indices per view (B,V) ---- | |
| # pos_idx_cpu = [self._get_pos_idx_cpu(str(s), V) for s in scan_ids] | |
| # targets = torch.stack(pos_idx_cpu, dim=0).to(device, non_blocking=True) # (B,V) | |
| # # ---- Common masks/constants ---- | |
| # eye = self._get_eye_mask(V, device) # (V,V) bool | |
| # NEG = -1e4 if view_pm_f.dtype in (torch.float16, torch.bfloat16) else -1e9 | |
| # # ============================================================ | |
| # # 1) PM–PM neighbor matching (existing, but safer masking) | |
| # # ============================================================ | |
| # logits_pm_pm = torch.bmm(view_pm_norm, view_pm_norm.transpose(1, 2)) * logit_scale # (B,V,V) | |
| # logits_pm_pm = logits_pm_pm.masked_fill(eye.unsqueeze(0), NEG) | |
| # loss_pm_pm_view = F.cross_entropy( | |
| # logits_pm_pm.reshape(B * V, V), | |
| # targets.reshape(B * V), | |
| # ) | |
| # # ============================================================ | |
| # # 2) NEW: PM -> RGB neighbor matching | |
| # # anchor: PM_i, candidates: RGB_j, target: chamfer NN index | |
| # # ============================================================ | |
| # # logits_pm_rgb = torch.bmm(view_pm_norm, view_rgb_norm.transpose(1, 2)) * logit_scale # (B,V,V) | |
| # # # mask j==i if your ranking excludes self and you don't want trivial matches | |
| # # logits_pm_rgb = logits_pm_rgb.masked_fill(eye.unsqueeze(0), NEG) | |
| # # loss_pm_rgb_nn = F.cross_entropy( | |
| # # logits_pm_rgb.reshape(B * V, V), | |
| # # targets.reshape(B * V), | |
| # # ) | |
| # # # ============================================================ | |
| # # # 3) NEW: PM -> TXT neighbor matching | |
| # # # ============================================================ | |
| # # logits_pm_txt = torch.bmm(view_pm_norm, view_txt_norm.transpose(1, 2)) * logit_scale # (B,V,V) | |
| # # logits_pm_txt = logits_pm_txt.masked_fill(eye.unsqueeze(0), NEG) | |
| # # loss_pm_txt_nn = F.cross_entropy( | |
| # # logits_pm_txt.reshape(B * V, V), | |
| # # targets.reshape(B * V), | |
| # # ) | |
| # # ---- Weights (tune) ---- | |
| # geo_w = 1e-1 # your existing weight style | |
| # loss_pm_pm_view = geo_w * loss_pm_pm_view | |
| # # loss_pm_rgb_nn = geo_w * loss_pm_rgb_nn | |
| # # loss_pm_txt_nn = geo_w * loss_pm_txt_nn | |
| # return { | |
| # "loss_rgb_pm_view": loss_rgb_pm_view, | |
| # "loss_txt_pm_view": loss_txt_pm_view, | |
| # "loss_rgb_pm_scene": loss_rgb_pm_scene, | |
| # "loss_txt_pm_scene": loss_txt_pm_scene, | |
| # # neighbor-matching regularizers | |
| # "loss_geo_pm_nn": loss_pm_pm_view, | |
| # # "loss_geo_pm_rgb_nn": loss_pm_rgb_nn, | |
| # # "loss_geo_pm_txt_nn": loss_pm_txt_nn, | |
| # } | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| # assumes you already have: | |
| # - LOSS_REGISTRY | |
| # - ClipLoss | |
| # - load_json | |
| class SceneViewPM_loss(nn.Module): | |
| def __init__(self, cfg, accelerator): | |
| super().__init__() | |
| self.accelerator = accelerator | |
| world_sz = self.accelerator.num_processes | |
| rank = self.accelerator.process_index | |
| self.contrast_loss = ClipLoss(rank=rank, world_size=world_sz) | |
| self.chamfer_ranking = load_json( | |
| "/home/m50048399/transfered/ye_project/Project2/chamfer_rankings.json" | |
| ) | |
| # ---- caches ---- | |
| self._pos_idx_cache = {} # (scan_id, V) -> LongTensor[V] on CPU | |
| self._dist_mat_cache = {} # (scan_id, V) -> FloatTensor[V,V] on CPU | |
| self._view_keys_cache = {} # scan_id -> sorted List[str] | |
| self._first_pos_cache = {} # scan_id -> Dict[str, Optional[str]] | |
| self._eye_mask_cache = {} # (V, device) -> BoolTensor[V,V] | |
| # ---- knobs for soft neighbor loss ---- | |
| # tau_d: softness over neighbor ranks/distances (smaller=sharper) | |
| self.tau_d = float(getattr(cfg, "pm_nn_tau_d", 0.35)) if cfg is not None else 0.35 | |
| # alpha: mix hard NN one-hot with soft distribution | |
| self.soft_alpha = float(getattr(cfg, "pm_nn_soft_alpha", 0.7)) if cfg is not None else 0.7 | |
| self._dbg_every = int(getattr(cfg, "dbg_every", 10)) if cfg is not None else 10 | |
| self._dbg_step = 0 | |
| # ------------------------- | |
| # cached diag mask | |
| # ------------------------- | |
| def _get_eye_mask(self, V: int, device: torch.device): | |
| key = (V, device) | |
| m = self._eye_mask_cache.get(key, None) | |
| if m is None: | |
| m = torch.eye(V, dtype=torch.bool, device=device) | |
| self._eye_mask_cache[key] = m | |
| return m | |
| # ------------------------- | |
| # per-scan cache build | |
| # ------------------------- | |
| def _ensure_scan_cached(self, scan_id: str): | |
| scan_id = str(scan_id) | |
| if scan_id in self._view_keys_cache and scan_id in self._first_pos_cache: | |
| return | |
| rank_dict = self.chamfer_ranking[scan_id] # {view_key: [neighbors...]} | |
| # normalize keys to str | |
| keys = [str(k) for k in rank_dict.keys()] | |
| try: | |
| keys_sorted = sorted(keys, key=lambda x: int(x)) | |
| except Exception: | |
| keys_sorted = keys | |
| # first non-self neighbor per key | |
| first_pos = {} | |
| for k in keys_sorted: | |
| ks = str(k) | |
| # tolerate int keys in json | |
| if ks in rank_dict: | |
| cands = rank_dict[ks] | |
| else: | |
| try: | |
| cands = rank_dict[int(ks)] | |
| except Exception: | |
| cands = [] | |
| fp = None | |
| for v in cands: | |
| vs = str(v) | |
| if vs != ks: | |
| fp = vs | |
| break | |
| first_pos[ks] = fp | |
| self._view_keys_cache[scan_id] = keys_sorted | |
| self._first_pos_cache[scan_id] = first_pos | |
| # ------------------------- | |
| # soft target helpers | |
| # ------------------------- | |
| def _soft_targets_from_dist(dist_bvv: torch.Tensor, tau_d: float, eye: torch.Tensor, eps: float = 1e-8): | |
| """ | |
| dist_bvv: (B,V,V) distances (>=0). Smaller = closer. | |
| eye: (V,V) bool diagonal mask | |
| returns: (B,V,V) row-stochastic soft targets, diag=0 | |
| """ | |
| # ensure diagonal excluded | |
| dist = dist_bvv.masked_fill(eye.unsqueeze(0), float("inf")) | |
| tgt_logits = -dist / max(tau_d, 1e-8) | |
| tgt_logits = tgt_logits.masked_fill(eye.unsqueeze(0), -1e9) | |
| p = torch.softmax(tgt_logits, dim=-1) # (B,V,V) | |
| p = p.masked_fill(eye.unsqueeze(0), 0.0) | |
| p = p / (p.sum(dim=-1, keepdim=True) + eps) | |
| return p | |
| def _soft_ce_from_logits(logits_bvv: torch.Tensor, p_bvv: torch.Tensor): | |
| """Soft-label cross entropy: -sum p * log softmax(logits)""" | |
| log_q = F.log_softmax(logits_bvv, dim=-1) | |
| loss = -(p_bvv * log_q).sum(dim=-1) # (B,V) | |
| return loss.mean() | |
| # ------------------------- | |
| # hard NN targets (existing) | |
| # ------------------------- | |
| def _get_pos_idx_cpu(self, scan_id: str, V: int) -> torch.LongTensor: | |
| """ | |
| CPU LongTensor [V], where pos_idx[i] is index of closest *other* view for view i. | |
| Cached per (scan_id, V). | |
| """ | |
| scan_id = str(scan_id) | |
| key = (scan_id, V) | |
| cached = self._pos_idx_cache.get(key, None) | |
| if cached is not None: | |
| return cached | |
| self._ensure_scan_cached(scan_id) | |
| view_keys = self._view_keys_cache[scan_id][:V] | |
| key2pos = {k: i for i, k in enumerate(view_keys)} | |
| first_pos = self._first_pos_cache[scan_id] | |
| pos_idx = [0] * V | |
| for i, cur in enumerate(view_keys): | |
| cur = str(cur) | |
| pv = first_pos.get(cur, None) | |
| if pv is None or pv not in key2pos: | |
| pos_idx[i] = (i + 1) % V | |
| else: | |
| pos_idx[i] = key2pos[pv] | |
| out = torch.tensor(pos_idx, dtype=torch.long, device="cpu") | |
| self._pos_idx_cache[key] = out | |
| return out | |
| # ------------------------- | |
| # NEW: distance matrix from ranking (soft neighbors) | |
| # ------------------------- | |
| def _get_rank_dist_cpu(self, scan_id: str, V: int) -> torch.FloatTensor: | |
| """ | |
| Build a (V,V) "distance" matrix from chamfer ranking list: | |
| dist[i,j] = rank_position_of_view_j_in_view_i_neighbor_list | |
| Smaller = closer. Missing entries get large distance. | |
| Cached per (scan_id, V). | |
| """ | |
| scan_id = str(scan_id) | |
| key = (scan_id, V) | |
| cached = self._dist_mat_cache.get(key, None) | |
| if cached is not None: | |
| return cached | |
| self._ensure_scan_cached(scan_id) | |
| rank_dict = self.chamfer_ranking[scan_id] | |
| view_keys = self._view_keys_cache[scan_id][:V] | |
| key2pos = {k: i for i, k in enumerate(view_keys)} | |
| # large distance for missing edges | |
| BIG = float(V + 50) | |
| dist = torch.full((V, V), BIG, dtype=torch.float32, device="cpu") | |
| for i, ki in enumerate(view_keys): | |
| kis = str(ki) | |
| # read neighbor ranking list | |
| if kis in rank_dict: | |
| neigh = rank_dict[kis] | |
| else: | |
| try: | |
| neigh = rank_dict[int(kis)] | |
| except Exception: | |
| neigh = [] | |
| # map neighbor -> rank (skip self) | |
| # rank starts at 0 for closest neighbor | |
| r = 0 | |
| for nb in neigh: | |
| nbs = str(nb) | |
| if nbs == kis: | |
| continue | |
| j = key2pos.get(nbs, None) | |
| if j is None: | |
| continue | |
| dist[i, j] = float(r) | |
| r += 1 | |
| if r >= V: # no need to go too deep | |
| break | |
| # diagonal zero (won't be used; will be masked) | |
| dist.fill_diagonal_(0.0) | |
| self._dist_mat_cache[key] = dist | |
| return dist | |
| def forward(self, data_dict): | |
| scan_ids = list(data_dict["scan_id"]) | |
| logit_scale = data_dict["logit_scale"] | |
| view_rgb = data_dict["inter_view_rgb_embed"] # (B,V,D) | |
| view_txt = data_dict["inter_view_txt_embed"] # (B,V,D) | |
| view_pm = data_dict["inter_view_pm_embed"] # (B,V,D) | |
| # view_context_pm = data_dict["inter_view_context_pm_embed"]# (B,V,D) | |
| view_ground_txt = data_dict["inter_view_ground_txt_embed"]# (B,V,D) | |
| scene_rgb = data_dict["scene_rgb_embed"] # (B,D) | |
| scene_txt = data_dict["scene_text_embed"] # (B,D) | |
| scene_pm = data_dict["scene_pm_embed"] # (B,D) | |
| B, V, D = view_pm.shape | |
| device = view_pm.device | |
| # ---- Normalize ---- | |
| view_pm_norm = F.normalize(view_pm, p=2, dim=-1) # (B,V,D) | |
| view_rgb_norm = F.normalize(view_rgb, p=2, dim=-1) | |
| view_txt_norm = F.normalize(view_txt, p=2, dim=-1) | |
| # view_context_pm_norm = F.normalize(view_context_pm, p=2, dim=-1) | |
| view_ground_txt_norm = F.normalize(view_ground_txt, p=2, dim=-1) | |
| scene_rgb = F.normalize(scene_rgb, p=2, dim=-1) | |
| scene_txt = F.normalize(scene_txt, p=2, dim=-1) | |
| scene_pm = F.normalize(scene_pm, p=2, dim=-1) | |
| # ---- Flatten for batch-wide CLIP losses (unchanged) ---- | |
| # view_pm_context_f = view_context_pm_norm.reshape(-1, D) # (B*V,D) | |
| view_pm_f = view_pm_norm.reshape(-1, D) # (B*V,D) | |
| view_rgb_f = view_rgb_norm.reshape(-1, D) | |
| view_txt_f = view_txt_norm.reshape(-1, D) | |
| # ---- Cross-modal CLIP losses (batch-wide, unchanged) ---- | |
| loss_rgb_pm_view = self.contrast_loss(view_pm_f, view_rgb_f, logit_scale) | |
| loss_txt_pm_view = self.contrast_loss(view_pm_f, view_txt_f, logit_scale) | |
| loss_rgb_pm_scene = self.contrast_loss(scene_pm, scene_rgb, logit_scale) | |
| loss_txt_pm_scene = self.contrast_loss(scene_pm, scene_txt, logit_scale) | |
| # ============================================================ | |
| # Grounded contrastive (WITHIN-SCENE ONLY): | |
| # context PM (anchor) <-> grounded text, negatives are other views in the SAME scene | |
| # ============================================================ | |
| gt_logits = torch.bmm(view_pm_norm, view_ground_txt_norm.transpose(1, 2)) * logit_scale # (B,V,V) | |
| # mask for views that actually have grounded text (pass from dataloader ideally) | |
| ground_mask = data_dict.get( | |
| "inter_view_ground_txt_mask", | |
| torch.ones((B, V), dtype=torch.bool, device=device) | |
| ) # (B,V) bool | |
| targets_diag = torch.arange(V, device=device).unsqueeze(0).expand(B, V) # (B,V) | |
| loss_ctxpm2gt = F.cross_entropy( | |
| gt_logits.reshape(B * V, V), | |
| targets_diag.reshape(B * V), | |
| reduction="none", | |
| ).reshape(B, V) | |
| loss_gt2ctxpm = F.cross_entropy( | |
| gt_logits.transpose(1, 2).reshape(B * V, V), | |
| targets_diag.reshape(B * V), | |
| reduction="none", | |
| ).reshape(B, V) | |
| den = ground_mask.float().sum().clamp_min(1.0) | |
| loss_grounded_view = ( | |
| ((loss_ctxpm2gt + loss_gt2ctxpm) * 0.5) * ground_mask.float() | |
| ).sum() / den | |
| # ---- Targets: hard nearest neighbor indices per view (B,V) ---- | |
| pos_idx_cpu = [self._get_pos_idx_cpu(str(s), V) for s in scan_ids] | |
| targets = torch.stack(pos_idx_cpu, dim=0).to(device, non_blocking=True) # (B,V) | |
| # ---- masks/constants ---- | |
| eye = self._get_eye_mask(V, device) # (V,V) bool | |
| NEG = -1e4 if view_pm_f.dtype in (torch.float16, torch.bfloat16) else -1e9 | |
| # ============================================================ | |
| # PM–PM neighbor matching (SOFT by ranking-distance) | |
| # ============================================================ | |
| logits_pm_pm = torch.bmm(view_pm_norm, view_pm_norm.transpose(1, 2)) * logit_scale # (B,V,V) | |
| logits_pm_pm = logits_pm_pm.masked_fill(eye.unsqueeze(0), NEG) | |
| # build (B,V,V) distance matrix from ranking (CPU cache -> GPU) | |
| dist_cpu = [self._get_rank_dist_cpu(str(s), V) for s in scan_ids] # list of (V,V) CPU | |
| dist_bvv = torch.stack(dist_cpu, dim=0).to(device, non_blocking=True) # (B,V,V) | |
| # soft targets from distances | |
| p_soft = self._soft_targets_from_dist(dist_bvv, tau_d=self.tau_d, eye=eye) | |
| # optional: mix with hard one-hot NN (stabilizes training) | |
| if self.soft_alpha > 0: | |
| hard = F.one_hot(targets, num_classes=V).float() # (B,V,V) | |
| hard = hard.masked_fill(eye.unsqueeze(0), 0.0) | |
| p_mix = self.soft_alpha * hard + (1.0 - self.soft_alpha) * p_soft | |
| p_mix = p_mix / (p_mix.sum(dim=-1, keepdim=True) + 1e-8) | |
| else: | |
| p_mix = p_soft | |
| loss_pm_pm_view = self._soft_ce_from_logits(logits_pm_pm, p_mix) | |
| # ---- Weights (tune) ---- | |
| geo_w = 1e-1 | |
| loss_pm_pm_view = geo_w * loss_pm_pm_view | |
| return { | |
| "loss_rgb_pm_view": loss_rgb_pm_view, | |
| "loss_txt_pm_view": loss_txt_pm_view, | |
| "loss_rgb_pm_scene": loss_rgb_pm_scene, | |
| "loss_txt_pm_scene": loss_txt_pm_scene, | |
| "loss_geo_pm_nn": loss_pm_pm_view, | |
| "loss_grounded_view": loss_grounded_view, | |
| } | |
| # def forward(self, data_dict): | |
| # scan_ids = list(data_dict["scan_id"]) | |
| # logit_scale = data_dict["logit_scale"] | |
| # view_rgb = data_dict["inter_view_rgb_embed"] # (B,V,D) | |
| # view_txt = data_dict["inter_view_txt_embed"] # (B,V,D) | |
| # view_pm = data_dict["inter_view_pm_embed"] # (B,V,D) | |
| # view_context_pm = data_dict["inter_view_context_pm_embed"] # (B,V,D) | |
| # view_ground_txt = data_dict["inter_view_ground_txt_embed"] # (B,V,D) | |
| # scene_rgb = data_dict["scene_rgb_embed"] # (B,D) | |
| # scene_txt = data_dict["scene_text_embed"] # (B,D) | |
| # scene_pm = data_dict["scene_pm_embed"] # (B,D) | |
| # B, V, D = view_pm.shape | |
| # device = view_pm.device | |
| # # ---- Normalize ---- | |
| # view_pm_norm = F.normalize(view_pm, p=2, dim=-1) # (B,V,D) | |
| # view_rgb_norm = F.normalize(view_rgb, p=2, dim=-1) | |
| # view_txt_norm = F.normalize(view_txt, p=2, dim=-1) | |
| # view_context_pm_norm = F.normalize(view_context_pm, p=2, dim=-1) | |
| # view_ground_txt_norm = F.normalize(view_ground_txt, p=2, dim=-1) | |
| # scene_rgb = F.normalize(scene_rgb, p=2, dim=-1) | |
| # scene_txt = F.normalize(scene_txt, p=2, dim=-1) | |
| # scene_pm = F.normalize(scene_pm, p=2, dim=-1) | |
| # # ============================================================ | |
| # # Cross-modal CLIP losses (WITHIN-SCENE ONLY): | |
| # # context PM (anchor) <-> RGB/TXT, negatives are other views in SAME scene | |
| # # ============================================================ | |
| # view_mask = data_dict.get( | |
| # "inter_view_valid_mask", | |
| # torch.ones((B, V), dtype=torch.bool, device=device) | |
| # ) # (B,V) bool | |
| # targets_diag = torch.arange(V, device=device) # (V,) | |
| # targets_bv = targets_diag.unsqueeze(0).expand(B, V) # (B,V) | |
| # # --- ctxPM <-> RGB --- | |
| # logits_ctxpm_rgb = torch.bmm( | |
| # view_context_pm_norm, view_rgb_norm.transpose(1, 2) | |
| # ) * logit_scale # (B,V,V) | |
| # loss_ctxpm2rgb = F.cross_entropy( | |
| # logits_ctxpm_rgb.reshape(B * V, V), | |
| # targets_bv.reshape(B * V), | |
| # reduction="none", | |
| # ).reshape(B, V) | |
| # loss_rgb2ctxpm = F.cross_entropy( | |
| # logits_ctxpm_rgb.transpose(1, 2).reshape(B * V, V), | |
| # targets_bv.reshape(B * V), | |
| # reduction="none", | |
| # ).reshape(B, V) | |
| # den_v = view_mask.float().sum().clamp_min(1.0) | |
| # loss_rgb_pm_view = ( | |
| # ((loss_ctxpm2rgb + loss_rgb2ctxpm) * 0.5) * view_mask.float() | |
| # ).sum() / den_v | |
| # # --- ctxPM <-> TXT --- | |
| # logits_ctxpm_txt = torch.bmm( | |
| # view_context_pm_norm, view_txt_norm.transpose(1, 2) | |
| # ) * logit_scale # (B,V,V) | |
| # loss_ctxpm2txt = F.cross_entropy( | |
| # logits_ctxpm_txt.reshape(B * V, V), | |
| # targets_bv.reshape(B * V), | |
| # reduction="none", | |
| # ).reshape(B, V) | |
| # loss_txt2ctxpm = F.cross_entropy( | |
| # logits_ctxpm_txt.transpose(1, 2).reshape(B * V, V), | |
| # targets_bv.reshape(B * V), | |
| # reduction="none", | |
| # ).reshape(B, V) | |
| # loss_txt_pm_view = ( | |
| # ((loss_ctxpm2txt + loss_txt2ctxpm) * 0.5) * view_mask.float() | |
| # ).sum() / den_v | |
| # # ---- Scene-level CLIP losses (batch-wide is fine; it's already per-sample) ---- | |
| # loss_rgb_pm_scene = self.contrast_loss(scene_pm, scene_rgb, logit_scale) | |
| # loss_txt_pm_scene = self.contrast_loss(scene_pm, scene_txt, logit_scale) | |
| # # ============================================================ | |
| # # Grounded contrastive (WITHIN-SCENE ONLY): | |
| # # context PM (anchor) <-> grounded text, negatives are other views in the SAME scene | |
| # # ============================================================ | |
| # gt_logits = torch.bmm( | |
| # view_context_pm_norm, view_ground_txt_norm.transpose(1, 2) | |
| # ) * logit_scale # (B,V,V) | |
| # ground_mask = data_dict.get( | |
| # "inter_view_ground_txt_mask", | |
| # torch.ones((B, V), dtype=torch.bool, device=device) | |
| # ) # (B,V) bool | |
| # # If you also have padding views, you typically want to AND them: | |
| # ground_mask = ground_mask & view_mask | |
| # loss_ctxpm2gt = F.cross_entropy( | |
| # gt_logits.reshape(B * V, V), | |
| # targets_bv.reshape(B * V), | |
| # reduction="none", | |
| # ).reshape(B, V) | |
| # loss_gt2ctxpm = F.cross_entropy( | |
| # gt_logits.transpose(1, 2).reshape(B * V, V), | |
| # targets_bv.reshape(B * V), | |
| # reduction="none", | |
| # ).reshape(B, V) | |
| # den_g = ground_mask.float().sum().clamp_min(1.0) | |
| # loss_grounded_view = ( | |
| # ((loss_ctxpm2gt + loss_gt2ctxpm) * 0.5) * ground_mask.float() | |
| # ).sum() / den_g | |
| # # ---- Targets: hard nearest neighbor indices per view (B,V) ---- | |
| # pos_idx_cpu = [self._get_pos_idx_cpu(str(s), V) for s in scan_ids] | |
| # targets = torch.stack(pos_idx_cpu, dim=0).to(device, non_blocking=True) # (B,V) | |
| # # ---- masks/constants ---- | |
| # eye = self._get_eye_mask(V, device) # (V,V) bool | |
| # NEG = -1e4 if view_pm_norm.dtype in (torch.float16, torch.bfloat16) else -1e9 | |
| # # ============================================================ | |
| # # PM–PM neighbor matching (SOFT by ranking-distance) | |
| # # ============================================================ | |
| # logits_pm_pm = torch.bmm(view_pm_norm, view_pm_norm.transpose(1, 2)) * logit_scale # (B,V,V) | |
| # logits_pm_pm = logits_pm_pm.masked_fill(eye.unsqueeze(0), NEG) | |
| # # build (B,V,V) distance matrix from ranking (CPU cache -> GPU) | |
| # dist_cpu = [self._get_rank_dist_cpu(str(s), V) for s in scan_ids] # list of (V,V) CPU | |
| # dist_bvv = torch.stack(dist_cpu, dim=0).to(device, non_blocking=True) # (B,V,V) | |
| # # soft targets from distances | |
| # p_soft = self._soft_targets_from_dist(dist_bvv, tau_d=self.tau_d, eye=eye) | |
| # # optional: mix with hard one-hot NN (stabilizes training) | |
| # if self.soft_alpha > 0: | |
| # hard = F.one_hot(targets, num_classes=V).float() # (B,V,V) | |
| # hard = hard.masked_fill(eye.unsqueeze(0), 0.0) | |
| # p_mix = self.soft_alpha * hard + (1.0 - self.soft_alpha) * p_soft | |
| # p_mix = p_mix / (p_mix.sum(dim=-1, keepdim=True) + 1e-8) | |
| # else: | |
| # p_mix = p_soft | |
| # loss_pm_pm_view = self._soft_ce_from_logits(logits_pm_pm, p_mix) | |
| # # ---- Weights (tune) ---- | |
| # geo_w = 1e-1 | |
| # loss_pm_pm_view = geo_w * loss_pm_pm_view | |
| # return { | |
| # "loss_rgb_pm_view": loss_rgb_pm_view, | |
| # "loss_txt_pm_view": loss_txt_pm_view, | |
| # "loss_rgb_pm_scene": loss_rgb_pm_scene, | |
| # "loss_txt_pm_scene": loss_txt_pm_scene, | |
| # "loss_geo_pm_nn": loss_pm_pm_view, | |
| # "loss_grounded_view": loss_grounded_view, | |
| # } |