File size: 6,044 Bytes
dadf189 | 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 | from __future__ import annotations
"""DINOv2 pretrained backbone with attention map extraction for TRAM.
Wraps facebook's DINOv2 ViT-S/14 (or ViT-B/14) and monkey-patches
the attention modules to capture per-layer attention weights needed by
TRAM token selection.
Returns the same 3-tuple interface as the custom ViT::
(patch_tokens, cls_token, attn_maps)
The monkey-patch replaces MemEffAttention/Attention forwards with standard
scaled-dot-product attention that stores the attention weight matrices.
This disables xformers memory-efficient attention but is necessary because
TRAM requires explicit (B, H, N, N) attention maps from every layer.
"""
import torch
import torch.nn as nn
class DINOv2Backbone(nn.Module):
"""Pretrained DINOv2 ViT backbone with attention map extraction.
Parameters
----------
model_name : str
DINOv2 hub model name (e.g. ``"dinov2_vits14"``).
image_size : int
Input resolution (square).
"""
KNOWN_MODELS = {
"dinov2_vits14", "dinov2_vitb14", "dinov2_vitl14",
"dinov2_vits14_reg", "dinov2_vitb14_reg", "dinov2_vitl14_reg",
}
def __init__(
self,
model_name: str = "dinov2_vits14",
image_size: int = 224,
):
super().__init__()
self.backbone = torch.hub.load(
"facebookresearch/dinov2",
model_name,
pretrained=True,
)
self.embed_dim: int = self.backbone.embed_dim
self._model_name = model_name
# ---- Grayscale -> RGB adapter (learned, init to equal mix) ----
self.gray_adapter = nn.Conv2d(1, 3, kernel_size=1, bias=False)
nn.init.constant_(self.gray_adapter.weight, 1.0 / 3.0)
# ---- Grid geometry ----
ps = self.backbone.patch_embed.patch_size
ps = ps[0] if isinstance(ps, (tuple, list)) else ps
self.patch_size: int = ps
self.grid_size: tuple[int, int] = (image_size // ps, image_size // ps)
# Number of prefix tokens (CLS + optional registers) for TRAM
self.num_prefix_tokens: int = 1 + getattr(
self.backbone, "num_register_tokens", 0
)
# ---- Attention map capture ----
self._attn_maps: list[torch.Tensor] = []
self._patch_attention_modules()
# ------------------------------------------------------------------
def _patch_attention_modules(self):
"""Replace each block's attention forward to capture weights.
DINOv2 uses ``MemEffAttention`` which delegates to xformers and
does NOT produce explicit attention matrices. We replace each
attention module's ``forward`` with a standard implementation
that computes and stores the (B, H, N, N) attention weights so
TRAM can compute per-layer centrality.
"""
for block in self.backbone.blocks:
attn_module = block.attn
# Grab layer references before closure
qkv_layer = attn_module.qkv
proj_layer = attn_module.proj
# DINOv2 may store attn_drop as float or nn.Dropout
raw_ad = attn_module.attn_drop
attn_drop_fn = raw_ad if callable(raw_ad) else nn.Dropout(float(raw_ad))
proj_drop_fn = getattr(attn_module, "proj_drop", nn.Identity())
if not callable(proj_drop_fn):
proj_drop_fn = nn.Dropout(float(proj_drop_fn))
num_heads = attn_module.num_heads
head_dim = self.embed_dim // num_heads
scale = head_dim ** -0.5
store = self._attn_maps
def _make_fwd(_qkv, _proj, _a_drop, _p_drop, _H, _s, _store):
def fwd(x):
B, N, C = x.shape
out = _qkv(x).reshape(B, N, 3, _H, C // _H).permute(2, 0, 3, 1, 4)
q, k, v = out.unbind(0)
w = (q * _s) @ k.transpose(-2, -1)
w = w.softmax(dim=-1)
_store.append(w.detach())
x = (_a_drop(w) @ v).transpose(1, 2).reshape(B, N, C)
x = _p_drop(_proj(x))
return x
return fwd
attn_module.forward = _make_fwd(
qkv_layer, proj_layer, attn_drop_fn, proj_drop_fn,
num_heads, scale, store,
)
# ------------------------------------------------------------------
def forward(
self, images: torch.Tensor,
) -> tuple[torch.Tensor, torch.Tensor, list[torch.Tensor]]:
"""
Args:
images: ``(B, C, H, W)`` grayscale (1-ch) or RGB (3-ch).
Returns:
patch_tokens: ``(B, P, D)`` patch features.
cls_token: ``(B, D)`` CLS token.
attn_maps: list of L tensors ``(B, H, N, N)`` per-layer
attention weights (N = P + num_prefix_tokens).
"""
# Grayscale -> RGB
if images.shape[1] == 1:
images = self.gray_adapter(images)
self._attn_maps.clear()
# Run through DINOv2 manually to collect attention maps
x = self.backbone.prepare_tokens_with_masks(images)
for block in self.backbone.blocks:
x = block(x)
x = self.backbone.norm(x)
# Split CLS / registers / patches
cls_token = x[:, 0] # (B, D)
nr = self.num_prefix_tokens - 1 # register count
patch_tokens = x[:, 1 + nr:] # (B, P, D)
attn_maps = list(self._attn_maps)
self._attn_maps.clear()
return patch_tokens, cls_token, attn_maps
# ------------------------------------------------------------------
def freeze(self):
"""Freeze backbone parameters (gray_adapter stays trainable)."""
for p in self.backbone.parameters():
p.requires_grad = False
def unfreeze(self):
"""Unfreeze backbone parameters."""
for p in self.backbone.parameters():
p.requires_grad = True
|