src/training/ablation_ijepa.py

"""
JEPA-GSC 消融实验训练代码

使用 I-JEPA encoder 的 self-attention 代替 SD attention 来 refine DINO 相似度矩阵。
实时计算 I-JEPA attention（不预提取）。
"""

import os
import sys
from typing import List
import torch
import torch.nn.functional as F
import torch.nn as nn
from torchvision.ops import roi_align

# 添加 I-JEPA 路径
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "third_party", "ijepa"))


# ============ I-JEPA Attention 提取模块 ============

class IJEPAAttentionExtractor(nn.Module):
    """
    从 I-JEPA encoder 提取 self-attention map
    
    参考 ProxyCLIP 的处理方式：在加载权重时预先插值 pos_embed 到目标分辨率，
    而不是在每次 forward 时动态插值，减少运行时开销。
    
    参考: https://github.com/mc-lan/ProxyCLIP/blob/main/proxyclip_segmentor.py
    """
    def __init__(self, checkpoint_path: str, model_name: str = "vit_huge",
                 patch_size: int = 14, target_img_size: int = 224,
                 attention_layer_indices: List[int] = None, device: str = "cuda"):
        super().__init__()
        
        self.patch_size = patch_size
        self.target_img_size = target_img_size
        
        # 动态导入 I-JEPA 模型
        from third_party.ijepa.src.models.vision_transformer import (
            vit_huge, vit_large, vit_base
        )
        
        model_fn = {
            "vit_huge": vit_huge,
            "vit_large": vit_large,
            "vit_base": vit_base,
        }[model_name]
        
        # 创建模型时使用目标分辨率（CLIP 需要的分辨率）
        self.model = model_fn(patch_size=patch_size, img_size=[target_img_size])
        self.num_layers = len(self.model.blocks)
        
        # 加载权重，在加载前先插值 pos_embed（参考 ProxyCLIP 的 MAE 处理方式）
        if checkpoint_path and os.path.exists(checkpoint_path):
            checkpoint = torch.load(checkpoint_path, map_location="cpu")
            
            if "encoder" in checkpoint:
                state_dict = checkpoint["encoder"]
            elif "target_encoder" in checkpoint:
                state_dict = checkpoint["target_encoder"]
            else:
                state_dict = checkpoint
            
            # 处理 key 前缀
            new_state_dict = {}
            for k, v in state_dict.items():
                if k.startswith("module."):
                    k = k[7:]
                new_state_dict[k] = v
            
            # 在加载前先插值 pos_embed（关键步骤，参考 ProxyCLIP）
            self._interpolate_pos_embed(new_state_dict, target_img_size, patch_size)
            
            # 加载权重
            msg = self.model.load_state_dict(new_state_dict, strict=False)
            print(f"Loaded I-JEPA checkpoint from {checkpoint_path}")
            print(f"  Target resolution: {target_img_size}x{target_img_size}")
            print(f"  Position embedding interpolated at load time")
            if msg.missing_keys:
                print(f"  Missing keys: {msg.missing_keys}")
        else:
            print(f"Warning: I-JEPA checkpoint not found at {checkpoint_path}, using random init")
        
        self.model = self.model.to(device).half().eval()
        
        # 冻结所有参数
        for p in self.model.parameters():
            p.requires_grad = False
        
        # 默认使用倒数第 4 和倒数第 2 层（类比 SD 的 [-4, -6]）
        if attention_layer_indices is None:
            attention_layer_indices = [-4, -2]
        
        self.attention_layers = [
            idx if idx >= 0 else self.num_layers + idx
            for idx in attention_layer_indices
        ]
    
    def _interpolate_pos_embed(self, state_dict: dict, target_img_size: int, patch_size: int):
        """
        在加载权重前插值 pos_embed（参考 ProxyCLIP/MAE 的处理方式）
        
        这样可以避免在每次 forward 时进行插值计算。
        """
        if 'pos_embed' not in state_dict:
            return
        
        pos_embed_checkpoint = state_dict['pos_embed']
        embedding_dim = pos_embed_checkpoint.shape[-1]
        num_patches_checkpoint = pos_embed_checkpoint.shape[1]
        
        # 目标 patch 数量
        num_patches_target = (target_img_size // patch_size) ** 2
        
        if num_patches_checkpoint == num_patches_target:
            print(f"  pos_embed size matches, no interpolation needed")
            return
        
        # 计算源和目标的 grid size
        src_grid_size = int(num_patches_checkpoint ** 0.5)
        tgt_grid_size = int(num_patches_target ** 0.5)
        
        print(f"  Interpolating pos_embed from {src_grid_size}x{src_grid_size} to {tgt_grid_size}x{tgt_grid_size}")
        
        # 2D bicubic 插值
        pos_embed_2d = pos_embed_checkpoint.reshape(1, src_grid_size, src_grid_size, embedding_dim)
        pos_embed_2d = pos_embed_2d.permute(0, 3, 1, 2)  # [1, C, H, W]
        pos_embed_2d = F.interpolate(
            pos_embed_2d,
            size=(tgt_grid_size, tgt_grid_size),
            mode='bicubic',
            align_corners=False
        )
        pos_embed_new = pos_embed_2d.permute(0, 2, 3, 1).reshape(1, -1, embedding_dim)
        
        state_dict['pos_embed'] = pos_embed_new
    
    @torch.no_grad()
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        提取 I-JEPA attention map
        
        由于 pos_embed 已在加载时预插值到目标分辨率，这里直接使用。
        
        Args:
            x: 输入图像 (B, 3, H, W)，已经过预处理，尺寸应与 target_img_size 一致
        
        Returns:
            attention: 聚合的 attention map (B, N, N)
        """
        # Patch embedding
        x = self.model.patch_embed(x)
        B, N, D = x.shape
        
        # Add positional embedding（已在加载时预插值，直接使用）
        # 如果输入尺寸与预期不符，interpolate_pos_encoding 会处理
        if N == self.model.pos_embed.shape[1]:
            x = x + self.model.pos_embed
        else:
            # Fallback: 运行时插值（不应该发生，因为我们已经对齐了分辨率）
            pos_embed = self.model.interpolate_pos_encoding(x, self.model.pos_embed)
            x = x + pos_embed
        
        # 收集 attention
        attentions = []
        
        for i, blk in enumerate(self.model.blocks):
            if i in self.attention_layers:
                # I-JEPA Block 支持 return_attention
                attn = blk(x, return_attention=True)  # (B, nHead, N, N)
                attentions.append(attn)
            x = blk(x)
        
        # 聚合多层 attention
        if len(attentions) > 0:
            attn_stack = torch.stack(attentions, dim=0)  # (L, B, nHead, N, N)
            attn_aggregated = attn_stack.mean(dim=(0, 2))  # (B, N, N)
        else:
            attn_aggregated = torch.eye(N, device=x.device, dtype=x.dtype).unsqueeze(0).expand(B, -1, -1)
        
        return attn_aggregated


# ============ JEPA-GSC 训练模块 ============

class DeCLIPWithREPAProjector(nn.Module):
    """与 declip_plus.py 保持一致的模型包装器"""
    
    def __init__(self, declip_model, clip_dim=768, hidden_dim=1024, vfm_dim=768, args=None):
        super().__init__()
        self.model = declip_model
        self.repa_layer_idx = args.repa_layer_idx
        self.projector = nn.Sequential(
            nn.Linear(clip_dim, hidden_dim),
            nn.SiLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.SiLU(),
            nn.Linear(hidden_dim, vfm_dim)
        )
        self.initialize_projector_weights()
        self.logit_scale = self.model.logit_scale

    def initialize_projector_weights(self):
        for module in self.projector.modules():
            if isinstance(module, nn.Linear):
                nn.init.xavier_uniform_(module.weight)
                if module.bias is not None:
                    nn.init.constant_(module.bias, 0)

    def encode_image(self, *args, **kwargs):
        return self.model.encode_image(*args, **kwargs)

    def encode_text(self, *args, **kwargs):
        return self.model.encode_text(*args, **kwargs)

    def encode_dense(self, *args, **kwargs):
        return self.model.encode_dense(*args, **kwargs)

    def encode_pseudo_boxes(self, images, rois_list, normalize=False, mode="qq", size=(1, 1)):
        student_roi_features, context, intermediate_layer_output = self.model.encode_pseudo_boxes(
            images, rois_list, normalize=normalize, mode=mode, size=size,
            get_intermediate_layer=[self.repa_layer_idx]
        )
        alpha = 0.3
        residual = intermediate_layer_output[0]
        intermediate_layer_output = self.projector(intermediate_layer_output[0])
        intermediate_layer_output = alpha * residual + intermediate_layer_output
        return student_roi_features, context, intermediate_layer_output

    def encode_masks(self, *args, **kwargs):
        return self.model.encode_masks(*args, **kwargs)

    def train(self, mode=True):
        self.model.train(mode)
        self.training = self.model.training
        return self

    def lock_image_tower(self, *args, **kwargs):
        return self.model.lock_image_tower(*args, **kwargs)

    def lock_text_tower(self, *args, **kwargs):
        return self.model.lock_text_tower(*args, **kwargs)

    @torch.jit.ignore
    def set_grad_checkpointing(self, enable=True):
        self.model.set_grad_checkpointing(enable)

    @torch.jit.ignore
    def no_weight_decay(self):
        return self.model.no_weight_decay()


class DeCLIP_IJEPA_GSC:
    """
    JEPA-GSC 消融实验：使用 I-JEPA attention 代替 SD attention
    """
    
    def __init__(self, ijepa_extractor: IJEPAAttentionExtractor):
        self.ijepa_extractor = ijepa_extractor

    def __call__(self, batch, student, teacher, vfm_model, args):
        losses = {}
        context_weight = args.loss_context_weight
        content_weight = args.loss_content_weight
        region_weight = args.loss_region_weight
        need_repa = args.repa_layer_idx != -1
        
        if args.distributed:
            student = student.module
        
        dtype_map = {"bf16": torch.bfloat16, "amp": torch.float16}
        input_dtype = dtype_map.get(args.precision, torch.float32)
        
        # I-JEPA 版本的数据有 5 个元素（包含 I-JEPA 专用图像）
        images, normed_boxes, image_crops, vfm_image, ijepa_image = prepare_inputs_ijepa(batch, args.device, input_dtype)
        
        # 实时计算 I-JEPA attention
        with torch.no_grad():
            ijepa_attn = self.ijepa_extractor(ijepa_image)
        
        loss_ensemble = self.intra_image_distill(
            student, teacher, vfm_model, images, normed_boxes, image_crops, vfm_image, ijepa_attn, args
        )
        
        loss_context, loss_content, loss_region = loss_ensemble[0], loss_ensemble[1], loss_ensemble[2]
        losses.update({"loss_context": loss_context * context_weight})
        losses.update({"loss_content": loss_content * content_weight})
        losses.update({"loss_region": loss_region * region_weight})
        
        if need_repa:
            loss_repa = loss_ensemble[2]
            losses.update({"loss_repa": loss_repa})
        
        return losses, len(images)

    def intra_image_distill(self, student, teacher, vfm_model, images, normed_boxes, image_crops, vfm_image, ijepa_attn, args):
        need_repa = args.repa_layer_idx != -1
        roi_size = (3, 3)
        B = images.shape[0]
        rois_list = []
        crops_list = []

        for bboxes_per_image, crops_per_image in zip(normed_boxes, image_crops):
            valid = bboxes_per_image[:, -1] > 0.5
            rois_list.append(bboxes_per_image[valid, :4])
            crops_list.append(crops_per_image[valid])

        image_crops = torch.cat(crops_list)
        
        if need_repa:
            student_roi_features, context, intermediate_layer_output = student.encode_pseudo_boxes(
                images, rois_list, normalize=True, mode=args.mode, size=roi_size
            )
        else:
            student_roi_features, context = student.encode_pseudo_boxes(
                images, rois_list, normalize=True, mode=args.mode, size=roi_size
            )

        with torch.no_grad():
            teacher_crop_features = teacher.encode_image(image_crops, normalize=True)
            intra_vfm_feats = extract_vfm_features(vfm_model, vfm_image, args)
            vfm_roi_features = extract_roi_features(intra_vfm_feats, rois_list, normalize=True)
            intra_vfm_feats = F.normalize(intra_vfm_feats, dim=1).flatten(start_dim=-2)
            intra_vfm_corr = torch.einsum('bci,bcj->bij', intra_vfm_feats, intra_vfm_feats)
            
            # 使用 I-JEPA attention refine DINO 相似度
            refined_intra_vfm_corr = refine_dino_with_ijepa(intra_vfm_corr, ijepa_attn, args.sd_refine_weight)

        student_intra_corr = compute_student_intra_image_similarity(images.shape[0], context, args)
        loss_context = context_loss(student_intra_corr, refined_intra_vfm_corr, teacher_temp=0.8)
        loss_content = soft_content_distill_loss(student_roi_features, teacher_crop_features)
        loss_region = region_scd_loss(student_roi_features, vfm_roi_features)
        
        if need_repa:
            loss_repa = repa_loss(intermediate_layer_output, intra_vfm_feats)
            return loss_context, loss_content, loss_repa
        else:
            return loss_context, loss_content, loss_region


# ============ 辅助函数 ============

def refine_dino_with_ijepa(dino_corr: torch.Tensor, ijepa_attn: torch.Tensor, refine_weight: float) -> torch.Tensor:
    """使用 I-JEPA attention refine DINO 相似度矩阵"""
    # 调整 I-JEPA attention 尺寸以匹配 DINO
    B_dino, HW_dino, _ = dino_corr.shape
    B_ijepa, HW_ijepa, _ = ijepa_attn.shape
    
    if HW_dino != HW_ijepa:
        ijepa_attn = resize_attention(ijepa_attn, int(HW_dino ** 0.5))
    
    residual = dino_corr
    dino_corr_propagated = torch.bmm(ijepa_attn, dino_corr)
    dino_corr_refined = dino_corr_propagated * refine_weight + residual * (1 - refine_weight)
    
    # 强制对角线为 1
    bs, hw, _ = dino_corr_refined.shape
    device = dino_corr_refined.device
    eye = torch.eye(hw, dtype=dino_corr_refined.dtype, device=device).unsqueeze(0).expand(bs, -1, -1)
    dino_corr_refined = dino_corr_refined * (1 - eye) + eye
    
    return dino_corr_refined


def resize_attention(attn: torch.Tensor, target_size: int) -> torch.Tensor:
    """调整 attention 矩阵尺寸"""
    B, N, _ = attn.shape
    current_size = int(N ** 0.5)
    
    if current_size == target_size:
        return attn
    
    # (B, N, N) -> (B, h, w, h, w) -> interpolate
    attn = attn.view(B, current_size, current_size, current_size, current_size)
    attn = attn.permute(0, 1, 3, 2, 4).contiguous()  # (B, h, h, w, w)
    attn = attn.view(B, current_size * current_size, current_size, current_size)
    attn = F.interpolate(attn, size=(target_size, target_size), mode='bilinear', align_corners=False)
    attn = attn.view(B, current_size, current_size, target_size * target_size)
    attn = attn.permute(0, 3, 1, 2).contiguous()
    attn = F.interpolate(attn, size=(target_size, target_size), mode='bilinear', align_corners=False)
    attn = attn.view(B, target_size * target_size, target_size * target_size)
    attn = F.softmax(attn, dim=-1)
    
    return attn


def prepare_inputs_ijepa(batch, device, dtype):
    """准备 JEPA-GSC 的输入（包含 I-JEPA 图像）"""
    images, normed_boxes, image_crops, vfm_image, ijepa_image = batch
    images = images.to(device=device, dtype=dtype, non_blocking=True)
    normed_boxes = normed_boxes.to(device=device, dtype=dtype, non_blocking=True)
    image_crops = image_crops.to(device=device, dtype=dtype, non_blocking=True)
    vfm_image = vfm_image.to(device=device, dtype=dtype, non_blocking=True)
    ijepa_image = ijepa_image.to(device=device, dtype=dtype, non_blocking=True)
    return images, normed_boxes, image_crops, vfm_image, ijepa_image


def extract_vfm_features(vfm_model, image, args):
    """从 VFM 模型提取特征"""
    if "dinov2" in args.use_vfm or "sd_dino" in args.use_vfm or "sam_dino" in args.use_vfm:
        vfm_feats = vfm_model.get_intermediate_layers(image, reshape=True)[0]
    elif 'sam' in args.use_vfm:
        vfm_feats = vfm_model.image_encoder(image)
    elif 'dino' in args.use_vfm:
        feat = vfm_model.get_intermediate_layers(image)[0]
        nb_im = feat.shape[0]
        patch_size = vfm_model.patch_embed.patch_size
        I, J = image[0].shape[-2] // patch_size, image[0].shape[-2] // patch_size
        vfm_feats = feat[:, 1:, :].reshape(nb_im, I, J, -1).permute(0, 3, 1, 2)
    else:
        raise NotImplementedError(f"VFM mode {args.use_vfm} is not implemented.")
    return vfm_feats


def extract_roi_features(x, normed_boxes, size=(3, 3), normalize=False):
    """提取 ROI 特征"""
    def _denormalize_boxes(normed_boxes, x):
        h, w = x.shape[-2:]
        denormed_boxes = []
        for boxes in normed_boxes:
            new_boxes = boxes.clone()
            new_boxes[:, [0, 2]] *= w
            new_boxes[:, [1, 3]] *= h
            denormed_boxes.append(new_boxes)
        return denormed_boxes
    
    if size == (1, 1):
        roi_feats = roi_align(x, _denormalize_boxes(normed_boxes, x), size, 1.0, -1, True)[..., 0, 0]
    else:
        roi_feats = roi_align(x, _denormalize_boxes(normed_boxes, x), size, 1.0, -1, True).flatten(start_dim=-2)
    
    if normalize:
        roi_feats = F.normalize(roi_feats, dim=1)
    return roi_feats


def compute_student_intra_image_similarity(B, context, args):
    """计算学生模型的图像内相似度"""
    N, _ = context[0].shape[1:] if isinstance(context, tuple) else context.shape[1:]
    
    if args.mode in ["qq_vfm_distill", "kk_vfm_distill", "vv_vfm_distill", "sanity_check"]:
        context = context.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
        context = F.normalize(context, dim=-1).transpose(-2, -1)
        student_context_similarity = torch.einsum("b c m, b c n -> b m n", context, context)
    elif args.mode == "csa_vfm_distill":
        q_feature, k_feature = context
        q_feature = q_feature.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
        k_feature = k_feature.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
        q_feature = F.normalize(q_feature, dim=-1).transpose(-2, -1)
        k_feature = F.normalize(k_feature, dim=-1).transpose(-2, -1)
        student_context_similarity = (
            torch.einsum("b c m, b c n -> b m n", q_feature, q_feature) +
            torch.einsum("b c m, b c n -> b m n", k_feature, k_feature)
        ) / 2.0
    elif args.mode == "all_vfm_distill":
        q_feature, k_feature, v_feature = context
        features = [q_feature, k_feature, v_feature]
        similarities = []
        for feature in features:
            feature = feature.transpose(0, 1).contiguous().view(N, B, -1).transpose(0, 1)
            feature = F.normalize(feature, dim=-1).transpose(-2, -1)
            similarities.append(torch.einsum("b c m, b c n -> b m n", feature, feature))
        student_context_similarity = sum(similarities) / len(features)
    else:
        raise NotImplementedError(f"Mode '{args.mode}' is not implemented.")
    
    return student_context_similarity


def context_loss(student_corr, teacher_corr, teacher_temp=1.0, student_temp=1.0):
    """Context distillation loss"""
    student_log_prob = F.log_softmax(student_corr / student_temp, dim=-1)
    with torch.no_grad():
        teacher_prob = F.softmax(teacher_corr / teacher_temp, dim=-1)
    kl_loss = F.kl_div(student_log_prob, teacher_prob, reduction='batchmean') * (teacher_temp * student_temp)
    return kl_loss


def soft_content_distill_loss(student_roi_features, teacher_crop_features, T=1.0):
    """Content distillation loss"""
    sim = torch.einsum('bpc,bc->bp', student_roi_features, teacher_crop_features)
    weights = F.softmax(sim / T, dim=1)
    weighted_student = (student_roi_features * weights.unsqueeze(-1)).sum(dim=1)
    weighted_student = F.normalize(weighted_student, dim=-1)
    cosine_similarity = (weighted_student * teacher_crop_features).sum(dim=-1)
    loss = 1.0 - cosine_similarity.mean()
    return loss


def region_scd_loss(student_roi_features, intra_vfm_roi_feats, T_teacher=1.0, T_student=1.0):
    """Region correlation loss"""
    with torch.no_grad():
        intra_vfm_roi_feats = intra_vfm_roi_feats.transpose(-2, -1).contiguous()
        teacher_corr = torch.einsum('bic,bjc->bij', intra_vfm_roi_feats, intra_vfm_roi_feats) / T_teacher
        teacher_prob = F.softmax(teacher_corr, dim=-1)
    student_corr = torch.einsum('bic,bjc->bij', student_roi_features, student_roi_features) / T_student
    student_log_prob = F.log_softmax(student_corr, dim=-1)
    loss = F.kl_div(student_log_prob, teacher_prob, reduction='batchmean') * (T_teacher * T_student)
    return loss


def repa_loss(clip_intermediate_out, vfm_out):
    """REPA loss"""
    vfm_out = vfm_out.transpose(1, 2)
    clip_intermediate_out = clip_intermediate_out[:, 1:]
    clip_intermediate_out = F.normalize(clip_intermediate_out, dim=-1)
    similarity = (clip_intermediate_out * vfm_out).sum(dim=-1)
    loss = -similarity.mean()
    return loss


# ============ 构建函数 ============

def build_ijepa_attention_extractor(args):
    """
    构建 I-JEPA attention 提取器
    
    参考 ProxyCLIP 的处理方式：
    1. 计算 CLIP 需要的目标分辨率（与 DINO patch 数对齐）
    2. 在加载权重时预先插值 pos_embed 到目标分辨率
    3. 运行时直接使用，无需额外插值开销
    """
    ijepa_ckpts = {
        "vit_huge_14": "/opt/tiger/xiaomoguhzz/ijepa/IN1K-vit.h.14-300e.pth.tar",
        "vit_huge_16": "/opt/tiger/xiaomoguhzz/ijepa/IN1K-vit.h.16-448px-300e.pth.tar",
    }
    
    # 根据 CLIP 的配置选择 I-JEPA 配置
    ijepa_type = getattr(args, 'ijepa_type', 'vit_huge_14')
    checkpoint = ijepa_ckpts.get(ijepa_type, ijepa_ckpts['vit_huge_14'])
    
    # 计算目标分辨率（与 DINO/CLIP 对齐）
    # L = det_image_size // downsample_factor 是 DINO 的 patch 数
    # I-JEPA patch_size=14，所以 I-JEPA 的分辨率 = L * 14
    L = args.det_image_size // args.downsample_factor
    target_img_size = L * 14  # I-JEPA patch_size = 14
    
    print(f"Building I-JEPA attention extractor:")
    print(f"  CLIP det_image_size={args.det_image_size}, downsample_factor={args.downsample_factor}")
    print(f"  Target patch count: {L}x{L} = {L*L}")
    print(f"  I-JEPA target resolution: {target_img_size}x{target_img_size}")
    
    extractor = IJEPAAttentionExtractor(
        checkpoint_path=checkpoint,
        model_name="vit_huge",
        patch_size=14,
        target_img_size=target_img_size,  # 目标分辨率，加载时预插值 pos_embed
        device=args.device
    )
    return extractor