File size: 6,996 Bytes
c9aee57 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | """
统一的 DINO 相似度矩阵 Refine 函数
所有方法共享相同的 refine 框架：
refined_dino_corr = refine_fn(dino_corr, external_attn, refine_weight)
区别仅在于 external_attn 的来源:
- SD-GSC: Stable Diffusion self-attention
- SAM-GSC: SAM image encoder self-attention
- JEPA-GSC: I-JEPA encoder self-attention
"""
import torch
import torch.nn.functional as F
def refine_dino_with_attn(dino_corr: torch.Tensor,
external_attn: torch.Tensor,
refine_weight: float = 0.3) -> torch.Tensor:
"""
使用外部 attention 来 refine DINO 相似度矩阵
这是 SD-GSC 的核心操作，也适用于 SAM-GSC 和 JEPA-GSC
Args:
dino_corr: DINO 特征的相似度矩阵 (B, HW, HW)
external_attn: 外部模型的 attention map (B, HW, HW)
refine_weight: refine 权重，控制外部 attention 的影响程度
Returns:
refined_corr: 精炼后的相似度矩阵 (B, HW, HW)
"""
residual = dino_corr
# 核心操作：使用 external attention 作为传播矩阵
# 这相当于让 DINO 的相似度沿着 external attention 定义的路径传播
dino_corr_propagated = torch.bmm(external_attn, dino_corr)
# 残差连接
dino_corr_refined = dino_corr_propagated * refine_weight + residual * (1 - refine_weight)
# 强制对角线为 1（自己和自己的相似度应该是 1）
B, HW, _ = dino_corr_refined.shape
device = dino_corr_refined.device
eye = torch.eye(HW, dtype=dino_corr_refined.dtype, device=device).unsqueeze(0).expand(B, -1, -1)
dino_corr_refined = dino_corr_refined * (1 - eye) + eye
return dino_corr_refined
def refine_dino_with_sd(dino_corr: torch.Tensor,
sd_attn: torch.Tensor,
refine_weight: float = 0.3) -> torch.Tensor:
"""
SD-GSC: 使用 Stable Diffusion self-attention refine DINO
这是原始方法，直接调用通用函数
"""
return refine_dino_with_attn(dino_corr, sd_attn, refine_weight)
def refine_dino_with_sam(dino_corr: torch.Tensor,
sam_attn: torch.Tensor,
refine_weight: float = 0.3) -> torch.Tensor:
"""
SAM-GSC: 使用 SAM image encoder self-attention refine DINO
SAM 的特点:
- 训练于大规模分割数据，对边界敏感
- 使用相对位置编码，空间感知能力强
"""
return refine_dino_with_attn(dino_corr, sam_attn, refine_weight)
def refine_dino_with_ijepa(dino_corr: torch.Tensor,
ijepa_attn: torch.Tensor,
refine_weight: float = 0.3) -> torch.Tensor:
"""
JEPA-GSC: 使用 I-JEPA encoder self-attention refine DINO
I-JEPA 的特点:
- 训练于 feature-level prediction 任务
- 学习到语义上一致的空间关系
"""
return refine_dino_with_attn(dino_corr, ijepa_attn, refine_weight)
def compute_dino_correlation(dino_feats: torch.Tensor) -> torch.Tensor:
"""
计算 DINO 特征的相似度矩阵
Args:
dino_feats: DINO 特征 (B, C, H, W) 或 (B, HW, C)
Returns:
dino_corr: 相似度矩阵 (B, HW, HW)
"""
if dino_feats.dim() == 4:
# (B, C, H, W) -> (B, C, HW)
B, C, H, W = dino_feats.shape
dino_feats = dino_feats.flatten(start_dim=-2) # (B, C, HW)
elif dino_feats.dim() == 3:
# (B, HW, C) -> (B, C, HW)
dino_feats = dino_feats.transpose(1, 2)
# L2 归一化
dino_feats = F.normalize(dino_feats, dim=1)
# 计算相似度矩阵
dino_corr = torch.einsum('bci,bcj->bij', dino_feats, dino_feats)
return dino_corr
def resize_attention(attn: torch.Tensor, target_size: int) -> torch.Tensor:
"""
调整 attention 矩阵的空间尺寸以匹配目标大小
Args:
attn: attention 矩阵 (B, N, N) 其中 N = H * W
target_size: 目标空间尺寸 (target_size^2 = N')
Returns:
resized_attn: (B, N', N')
"""
B, N, _ = attn.shape
current_size = int(N ** 0.5)
if current_size == target_size:
return attn
# 重塑为 4D 进行插值
# (B, N, N) -> (B, h, w, h, w)
attn_4d = attn.view(B, current_size, current_size, current_size, current_size)
# 分别对两个空间维度进行插值
# 首先处理 query 维度
attn_4d = attn_4d.permute(0, 3, 4, 1, 2).contiguous() # (B, h_k, w_k, h_q, w_q)
attn_4d = attn_4d.view(B * current_size * current_size, current_size, current_size)
attn_4d = attn_4d.unsqueeze(1) # (B*N, 1, h_q, w_q)
attn_4d = F.interpolate(attn_4d, size=(target_size, target_size), mode='bilinear', align_corners=False)
attn_4d = attn_4d.squeeze(1).view(B, current_size, current_size, target_size, target_size)
# 然后处理 key 维度
attn_4d = attn_4d.permute(0, 3, 4, 1, 2).contiguous() # (B, h_q', w_q', h_k, w_k)
attn_4d = attn_4d.view(B * target_size * target_size, current_size, current_size)
attn_4d = attn_4d.unsqueeze(1)
attn_4d = F.interpolate(attn_4d, size=(target_size, target_size), mode='bilinear', align_corners=False)
attn_4d = attn_4d.squeeze(1).view(B, target_size, target_size, target_size, target_size)
# 重塑回 3D
attn_resized = attn_4d.view(B, target_size * target_size, target_size * target_size)
# 重新归一化
attn_resized = F.softmax(attn_resized, dim=-1)
return attn_resized
# ============ 测试代码 ============
if __name__ == "__main__":
print("Testing refine functions...")
B, HW = 2, 256 # 16x16 patches
device = "cuda" if torch.cuda.is_available() else "cpu"
# 模拟 DINO 相似度矩阵
dino_corr = torch.randn(B, HW, HW, device=device)
dino_corr = F.softmax(dino_corr, dim=-1)
# 模拟外部 attention
external_attn = torch.randn(B, HW, HW, device=device)
external_attn = F.softmax(external_attn, dim=-1)
# 测试 refine 函数
refined_sd = refine_dino_with_sd(dino_corr, external_attn, 0.3)
refined_sam = refine_dino_with_sam(dino_corr, external_attn, 0.3)
refined_ijepa = refine_dino_with_ijepa(dino_corr, external_attn, 0.3)
print(f"Input dino_corr shape: {dino_corr.shape}")
print(f"Refined (SD) shape: {refined_sd.shape}")
print(f"Refined (SAM) shape: {refined_sam.shape}")
print(f"Refined (I-JEPA) shape: {refined_ijepa.shape}")
# 验证对角线为 1
diag_values = torch.diagonal(refined_sd, dim1=1, dim2=2)
print(f"Diagonal values (should be 1): {diag_values[0, :5]}")
# 测试 resize
attn_64 = torch.randn(B, 64, 64, device=device)
attn_64 = F.softmax(attn_64, dim=-1)
attn_resized = resize_attention(attn_64, target_size=16)
print(f"Resized attention: {attn_64.shape} -> {attn_resized.shape}")
print("All tests passed!")
|