Add files using upload-large-folder tool

experimental/SimFeatUp/featup/featurizers/maskclip/simple_tokenizer.py

@@ -0,0 +1,138 @@
+import gzip
+import html
+import os
+from collections.abc import Sequence
+from functools import lru_cache
+
+import ftfy
+import regex as re
+
+
+@lru_cache()
+def default_bpe():
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz")
+
+
+@lru_cache()
+def bytes_to_unicode():
+    """
+    Returns list of utf-8 byte and a corresponding list of unicode strings.
+    The reversible bpe codes work on unicode strings.
+    This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
+    When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
+    This is a signficant percentage of your normal, say, 32K bpe vocab.
+    To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
+    And avoids mapping to whitespace/control characters the bpe code barfs on.
+    """
+    bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1))
+    cs = bs[:]
+    n = 0
+    for b in range(2**8):
+        if b not in bs:
+            bs.append(b)
+            cs.append(2**8+n)
+            n += 1
+    cs = [chr(n) for n in cs]
+    return dict(zip(bs, cs))
+
+
+def get_pairs(word):
+    """Return set of symbol pairs in a word.
+    Word is represented as tuple of symbols (symbols being variable-length strings).
+    """
+    pairs = set()
+    prev_char = word[0]
+    for char in word[1:]:
+        pairs.add((prev_char, char))
+        prev_char = char
+    return pairs
+
+
+def basic_clean(text):
+    # note: pretty hacky but it is okay!
+    # ge: bad.this is used by the cli_multi_label.py script
+    if not isinstance(text, str):
+        text = ', '.join(text)
+
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r'\s+', ' ', text)
+    text = text.strip()
+    return text
+
+
+class SimpleTokenizer(object):
+    def __init__(self, bpe_path: str = default_bpe()):
+        self.byte_encoder = bytes_to_unicode()
+        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
+        merges = gzip.open(bpe_path).read().decode("utf-8").split('\n')
+        merges = merges[1:49152-256-2+1]
+        merges = [tuple(merge.split()) for merge in merges]
+        vocab = list(bytes_to_unicode().values())
+        vocab = vocab + [v+'</w>' for v in vocab]
+        for merge in merges:
+            vocab.append(''.join(merge))
+        vocab.extend(['<|startoftext|>', '<|endoftext|>'])
+        self.encoder = dict(zip(vocab, range(len(vocab))))
+        self.decoder = {v: k for k, v in self.encoder.items()}
+        self.bpe_ranks = dict(zip(merges, range(len(merges))))
+        self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'}
+        self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE)
+
+    def bpe(self, token):
+        if token in self.cache:
+            return self.cache[token]
+        word = tuple(token[:-1]) + ( token[-1] + '</w>',)
+        pairs = get_pairs(word)
+
+        if not pairs:
+            return token+'</w>'
+
+        while True:
+            bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf')))
+            if bigram not in self.bpe_ranks:
+                break
+            first, second = bigram
+            new_word = []
+            i = 0
+            while i < len(word):
+                try:
+                    j = word.index(first, i)
+                    new_word.extend(word[i:j])
+                    i = j
+                except:
+                    new_word.extend(word[i:])
+                    break
+
+                if word[i] == first and i < len(word)-1 and word[i+1] == second:
+                    new_word.append(first+second)
+                    i += 2
+                else:
+                    new_word.append(word[i])
+                    i += 1
+            new_word = tuple(new_word)
+            word = new_word
+            if len(word) == 1:
+                break
+            else:
+                pairs = get_pairs(word)
+        word = ' '.join(word)
+        self.cache[token] = word
+        return word
+
+    def encode(self, text):
+        bpe_tokens = []
+        text = whitespace_clean(basic_clean(text)).lower()
+        for token in re.findall(self.pat, text):
+            token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8'))
+            bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' '))
+        return bpe_tokens
+
+    def decode(self, tokens):
+        text = ''.join([self.decoder[token] for token in tokens])
+        text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('</w>', ' ')
+        return text

experimental/SimFeatUp/featup/featurizers/maskclip/xclip.py

@@ -0,0 +1,247 @@
+import hashlib
+import os
+import urllib
+import warnings
+from typing import Any, Union, List
+from pkg_resources import packaging
+
+import torch
+from PIL import Image
+from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
+from tqdm import tqdm
+
+from .xmodel import build_model
+from .simple_tokenizer import SimpleTokenizer as _Tokenizer
+
+try:
+    from torchvision.transforms import InterpolationMode
+
+    BICUBIC = InterpolationMode.BICUBIC
+except ImportError:
+    BICUBIC = Image.BICUBIC
+
+if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"):
+    warnings.warn("PyTorch version 1.7.1 or higher is recommended")
+
+__all__ = ["available_models", "load", "tokenize"]
+_tokenizer = _Tokenizer()
+
+_MODELS = {
+    "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt",
+    "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt",
+    "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt",
+    "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt",
+    "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt",
+    "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt",
+    "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt",
+    "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt",
+    "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt",
+}
+
+
+def _download(url: str, root: str):
+    os.makedirs(root, exist_ok=True)
+    filename = os.path.basename(url)
+
+    expected_sha256 = url.split("/")[-2]
+    download_target = os.path.join(root, filename)
+
+    if os.path.exists(download_target) and not os.path.isfile(download_target):
+        raise RuntimeError(f"{download_target} exists and is not a regular file")
+
+    if os.path.isfile(download_target):
+        if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256:
+            return download_target
+        else:
+            warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file")
+
+    print(f"Downloading CLIP model from {url}")
+    with urllib.request.urlopen(url) as source, open(download_target, "wb") as output:
+        with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True,
+                  unit_divisor=1024) as loop:
+            while True:
+                buffer = source.read(8192)
+                if not buffer:
+                    break
+
+                output.write(buffer)
+                loop.update(len(buffer))
+
+    if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256:
+        raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match")
+
+    return download_target
+
+
+def _convert_image_to_rgb(image):
+    return image.convert("RGB")
+
+
+def _transform(n_px):
+    return Compose([
+        Resize(n_px, interpolation=BICUBIC),
+        CenterCrop(n_px),
+        _convert_image_to_rgb,
+        ToTensor(),
+        Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
+    ])
+
+
+def available_models() -> List[str]:
+    """Returns the names of available CLIP models"""
+    return list(_MODELS.keys())
+
+
+TORCH_HUB_ROOT = os.path.expandvars(os.getenv("$TORCH_HUB_ROOT", "$HOME/.torch_hub"))
+
+
+def load(
+        name: str,
+        device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu",
+        jit: bool = False,
+        download_root: str = None
+):
+    """Load a CLIP model
+
+    Parameters
+    ----------
+    name : str
+        A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict
+
+    device : Union[str, torch.device]
+        The device to put the loaded model
+
+    jit : bool
+        Whether to load the optimized JIT model or more hackable non-JIT model (default).
+
+    download_root: str
+        path to download the model files; by default, it uses "~/.torch_hub/clip"
+
+    Returns
+    -------
+    model : torch.nn.Module
+        The CLIP model
+
+    preprocess : Callable[[PIL.Image], torch.Tensor]
+        A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input
+    """
+    if name in _MODELS:
+        model_path = _download(_MODELS[name], download_root or TORCH_HUB_ROOT)
+    elif os.path.isfile(name):
+        model_path = name
+    else:
+        raise RuntimeError(f"Model {name} not found; available models = {available_models()}")
+
+    with open(model_path, 'rb') as opened_file:
+        try:
+            # loading JIT archive
+            model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval()
+            state_dict = None
+        except RuntimeError:
+            # loading saved state dict
+            if jit:
+                warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead")
+                jit = False
+            state_dict = torch.load(opened_file, map_location="cpu")
+
+    if not jit:
+        model = build_model(state_dict or model.state_dict()).to(device)
+        if str(device) == "cpu":
+            model.float()
+        return model, _transform(model.visual.input_resolution)
+
+    # patch the device names
+    device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
+    device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1]
+
+    def patch_device(module):
+        try:
+            graphs = [module.graph] if hasattr(module, "graph") else []
+        except RuntimeError:
+            graphs = []
+
+        if hasattr(module, "forward1"):
+            graphs.append(module.forward1.graph)
+
+        for graph in graphs:
+            for node in graph.findAllNodes("prim::Constant"):
+                if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"):
+                    node.copyAttributes(device_node)
+
+    model.apply(patch_device)
+    patch_device(model.encode_image)
+    patch_device(model.encode_text)
+
+    # patch dtype to float32 on CPU
+    if str(device) == "cpu":
+        float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[])
+        float_input = list(float_holder.graph.findNode("aten::to").inputs())[1]
+        float_node = float_input.node()
+
+        def patch_float(module):
+            try:
+                graphs = [module.graph] if hasattr(module, "graph") else []
+            except RuntimeError:
+                graphs = []
+
+            if hasattr(module, "forward1"):
+                graphs.append(module.forward1.graph)
+
+            for graph in graphs:
+                for node in graph.findAllNodes("aten::to"):
+                    inputs = list(node.inputs())
+                    for i in [1, 2]:  # dtype can be the second or third argument to aten::to()
+                        if inputs[i].node()["value"] == 5:
+                            inputs[i].node().copyAttributes(float_node)
+
+        model.apply(patch_float)
+        patch_float(model.encode_image)
+        patch_float(model.encode_text)
+
+        model.float()
+
+    return model, _transform(model.input_resolution.item())
+
+
+def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[
+    torch.IntTensor, torch.LongTensor]:
+    """
+    Returns the tokenized representation of given input string(s)
+
+    Parameters
+    ----------
+    texts : Union[str, List[str]]
+        An input string or a list of input strings to tokenize
+
+    context_length : int
+        The context length to use; all CLIP models use 77 as the context length
+
+    truncate: bool
+        Whether to truncate the text in case its encoding is longer than the context length
+
+    Returns
+    -------
+    A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length].
+    We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long.
+    """
+    if isinstance(texts, str):
+        texts = [texts]
+
+    sot_token = _tokenizer.encoder["<|startoftext|>"]
+    eot_token = _tokenizer.encoder["<|endoftext|>"]
+    all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts]
+    if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"):
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+    else:
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.int)
+
+    for i, tokens in enumerate(all_tokens):
+        if len(tokens) > context_length:
+            if truncate:
+                tokens = tokens[:context_length]
+                tokens[-1] = eot_token
+            else:
+                raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}")
+        result[i, :len(tokens)] = torch.tensor(tokens)
+
+    return result

experimental/SimFeatUp/featup/featurizers/maskclip/xmodel.py

@@ -0,0 +1,535 @@
+from collections import OrderedDict
+from typing import Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from .interpolate import interpolate_positional_embedding
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1):
+        super().__init__()
+
+        # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
+        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.relu2 = nn.ReLU(inplace=True)
+
+        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
+
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
+        self.relu3 = nn.ReLU(inplace=True)
+
+        self.downsample = None
+        self.stride = stride
+
+        if stride > 1 or inplanes != planes * Bottleneck.expansion:
+            # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
+            self.downsample = nn.Sequential(OrderedDict([
+                ("-1", nn.AvgPool2d(stride)),
+                ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
+                ("1", nn.BatchNorm2d(planes * self.expansion))
+            ]))
+
+    def forward(self, x: torch.Tensor):
+        identity = x
+
+        out = self.relu1(self.bn1(self.conv1(x)))
+        out = self.relu2(self.bn2(self.conv2(out)))
+        out = self.avgpool(out)
+        out = self.bn3(self.conv3(out))
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu3(out)
+        return out
+
+
+class AttentionPool2d(nn.Module):
+    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
+        super().__init__()
+        self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+        self.spacial_dim = spacial_dim
+
+    def forward(self, x):
+        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
+        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
+        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
+        x, _ = F.multi_head_attention_forward(
+            query=x[:1], key=x, value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False
+        )
+        return x.squeeze(0)
+
+    def forward_v(self, x: torch.Tensor):
+        """
+        Forward function for computing the value features for dense prediction (i.e., features for every image patch).
+        """
+        _, _, w, h = x.shape
+        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
+        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
+
+        # Interpolate positional embedding to match the size of the input
+        interpolated_pe = interpolate_positional_embedding(self.positional_embedding, x.permute(1, 0, 2), patch_size=1, w=w, h=h)
+        x = x + interpolated_pe[:, None, :]  # (HW+1)NC
+
+        v_in = F.linear(x, self.v_proj.weight, self.v_proj.bias)
+        v_out = F.linear(v_in, self.c_proj.weight, self.c_proj.bias)
+        v_out = v_out.permute(1, 0, 2)  # (HW+1)NC -> N(HW+1)C
+        return v_out
+
+
+class ModifiedResNet(nn.Module):
+    """
+    A ResNet class that is similar to torchvision's but contains the following changes:
+    - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
+    - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
+    - The final pooling layer is a QKV attention instead of an average pool
+    """
+
+    def __init__(self, layers, output_dim, heads, input_resolution=224, width=64):
+        super().__init__()
+        self.output_dim = output_dim
+        self.input_resolution = input_resolution
+
+        # the 3-layer stem
+        self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(width // 2)
+        self.relu1 = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(width // 2)
+        self.relu2 = nn.ReLU(inplace=True)
+        self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(width)
+        self.relu3 = nn.ReLU(inplace=True)
+        self.avgpool = nn.AvgPool2d(2)
+
+        # residual layers
+        self._inplanes = width  # this is a *mutable* variable used during construction
+        self.layer1 = self._make_layer(width, layers[0])
+        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
+        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
+        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
+
+        embed_dim = width * 32  # the ResNet feature dimension
+        self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim)
+
+    def _make_layer(self, planes, blocks, stride=1):
+        layers = [Bottleneck(self._inplanes, planes, stride)]
+
+        self._inplanes = planes * Bottleneck.expansion
+        for _ in range(1, blocks):
+            layers.append(Bottleneck(self._inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x, patch_output: bool = False):
+        def stem(x):
+            x = self.relu1(self.bn1(self.conv1(x)))
+            x = self.relu2(self.bn2(self.conv2(x)))
+            x = self.relu3(self.bn3(self.conv3(x)))
+            x = self.avgpool(x)
+            return x
+
+        x = x.type(self.conv1.weight.dtype)
+        x = stem(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        if patch_output:
+            x = self.attnpool.forward_v(x)
+            x = x[:, 1:, :]  # remove the cls token
+        else:
+            x = self.attnpool(x)
+
+        return x
+
+
+class LayerNorm(nn.LayerNorm):
+    """Subclass torch's LayerNorm to handle fp16."""
+
+    def forward(self, x: torch.Tensor):
+        orig_type = x.dtype
+        ret = super().forward(x.type(torch.float32))
+        return ret.type(orig_type)
+
+
+class QuickGELU(nn.Module):
+    def forward(self, x: torch.Tensor):
+        return x * torch.sigmoid(1.702 * x)
+
+
+class ResidualAttentionBlock(nn.Module):
+    def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
+        super().__init__()
+
+        self.attn = nn.MultiheadAttention(d_model, n_head)
+        self.ln_1 = LayerNorm(d_model)
+        self.mlp = nn.Sequential(OrderedDict([
+            ("c_fc", nn.Linear(d_model, d_model * 4)),
+            ("gelu", QuickGELU()),
+            ("c_proj", nn.Linear(d_model * 4, d_model))
+        ]))
+        self.ln_2 = LayerNorm(d_model)
+        self.attn_mask = attn_mask
+
+        # self.n_head = n_head
+        # self.head_dim = d_model // n_head
+        # self.scale = self.head_dim ** -0.5
+
+    def attention(self, x: torch.Tensor):
+        self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
+        return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
+    
+    def forward_x(self, x: torch.Tensor):
+        """
+        Forward function for computing the value features for dense prediction (i.e., features for every image patch).
+        """
+        return x
+
+    def forward(self, x: torch.Tensor):
+        x = x + self.attention(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+    
+    # TODO: qq, kk, vv forward
+    def forward_qkv(self, x: torch.Tensor):
+        """
+        Forward function for computing the value features for dense prediction (i.e., features for every image patch).
+        """
+        # Get the weights and biases for the value projection, multihead attention uses 3 * embed_dim for the input projection
+        # x [197, 4, 768]
+        _, bsz, embed_dim = x.shape
+        v_in_proj_weight = self.attn.in_proj_weight[-self.attn.embed_dim:]
+        v_in_proj_bias = self.attn.in_proj_bias[-self.attn.embed_dim:]
+
+        q_in_proj_weight = self.attn.in_proj_weight[:self.attn.embed_dim]
+        q_in_proj_bias = self.attn.in_proj_bias[:self.attn.embed_dim:]
+
+        v_in = F.linear(self.ln_1(x), v_in_proj_weight, v_in_proj_bias)
+        # v_out = F.linear(v_in, self.attn.out_proj.weight, self.attn.out_proj.bias)
+
+        q_in = F.linear(self.ln_1(x), q_in_proj_weight, q_in_proj_bias)
+        # q_out = F.linear(q_in, self.attn.out_proj.weight, self.attn.out_proj.bias)
+
+        q_in = q_in.contiguous().view(-1, bsz * self.n_head, self.head_dim).transpose(0, 1)
+        v_in = v_in.contiguous().view(-1, bsz * self.n_head, self.head_dim).transpose(0, 1)
+
+        qq_attn = torch.bmm(q_in, q_in.transpose(1, 2)) * self.scale
+        attn_weights = F.softmax(qq_attn, dim=-1)
+        attn_output = torch.bmm(attn_weights, v_in) # [12, 197, 64]
+        
+        attn_output = attn_output.transpose(0, 1).contiguous().view(-1, bsz, embed_dim)
+        out = F.linear(attn_output, self.attn.out_proj.weight, self.attn.out_proj.bias)
+
+        # Using the value features works the best. Adding this to 'x' or feeding 'v' to the LayerNorm then MLP degrades the performance
+        return out
+
+
+
+class Transformer(nn.Module):
+    def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
+        super().__init__()
+        self.width = width
+        self.layers = layers
+        self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
+
+    def forward(self, x: torch.Tensor):
+        return self.resblocks(x)
+
+
+class VisionTransformer(nn.Module):
+    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int):
+        super().__init__()
+        self.input_resolution = input_resolution
+        self.output_dim = output_dim
+        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)
+
+        scale = width ** -0.5
+        self.class_embedding = nn.Parameter(scale * torch.randn(width))
+        self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
+        self.ln_pre = LayerNorm(width)
+
+        self.transformer = Transformer(width, layers, heads)
+
+        self.ln_post = LayerNorm(width)
+        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
+
+        self.patch_size = patch_size
+
+    def forward(self, x: torch.Tensor, patch_output: bool = False):
+        _, _, w, h = x.shape
+
+        x = self.conv1(x)  # shape = [*, width, grid, grid]
+        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
+        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
+        x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # shape = [*, grid ** 2 + 1, width]
+        x = x + interpolate_positional_embedding(self.positional_embedding, x, patch_size=self.patch_size, w=w, h=h)
+        x = self.ln_pre(x)
+
+        x = x.permute(1, 0, 2)  # NLD -> LND
+
+        if patch_output:
+            *layers, last_resblock = self.transformer.resblocks
+            penultimate = nn.Sequential(*layers)
+
+            x = penultimate(x)
+            x = last_resblock.forward_x(x)
+            x = x.permute(1, 0, 2)  # LND -> NLD
+
+            # Extract the patch tokens, not the class token
+            x = x[:, 1:, :]
+            x = self.ln_post(x)
+            if self.proj is not None:
+                # This is equivalent to conv1d
+                x = x @ self.proj
+            return x
+
+        x = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+
+        x = self.ln_post(x[:, 0, :])
+
+        if self.proj is not None:
+            x = x @ self.proj
+
+        return x
+
+
+class CLIP(nn.Module):
+    def __init__(self,
+                 embed_dim: int,
+                 # vision
+                 image_resolution: int,
+                 vision_layers: Union[Tuple[int, int, int, int], int],
+                 vision_width: int,
+                 vision_patch_size: int,
+                 # text
+                 context_length: int,
+                 vocab_size: int,
+                 transformer_width: int,
+                 transformer_heads: int,
+                 transformer_layers: int
+                 ):
+        super().__init__()
+
+        self.context_length = context_length
+
+        if isinstance(vision_layers, (tuple, list)):
+            vision_heads = vision_width * 32 // 64
+            self.visual = ModifiedResNet(
+                layers=vision_layers,
+                output_dim=embed_dim,
+                heads=vision_heads,
+                input_resolution=image_resolution,
+                width=vision_width
+            )
+        else:
+            vision_heads = vision_width // 64
+            self.visual = VisionTransformer(
+                input_resolution=image_resolution,
+                patch_size=vision_patch_size,
+                width=vision_width,
+                layers=vision_layers,
+                heads=vision_heads,
+                output_dim=embed_dim
+            )
+
+        self.transformer = Transformer(
+            width=transformer_width,
+            layers=transformer_layers,
+            heads=transformer_heads,
+            attn_mask=self.build_attention_mask()
+        )
+
+        self.vocab_size = vocab_size
+        self.token_embedding = nn.Embedding(vocab_size, transformer_width)
+        self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
+        self.ln_final = LayerNorm(transformer_width)
+
+        self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
+        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
+
+        self.initialize_parameters()
+
+    def initialize_parameters(self):
+        nn.init.normal_(self.token_embedding.weight, std=0.02)
+        nn.init.normal_(self.positional_embedding, std=0.01)
+
+        if isinstance(self.visual, ModifiedResNet):
+            if self.visual.attnpool is not None:
+                std = self.visual.attnpool.c_proj.in_features ** -0.5
+                nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std)
+
+            for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]:
+                for name, param in resnet_block.named_parameters():
+                    if name.endswith("bn3.weight"):
+                        nn.init.zeros_(param)
+
+        proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
+        attn_std = self.transformer.width ** -0.5
+        fc_std = (2 * self.transformer.width) ** -0.5
+        for block in self.transformer.resblocks:
+            nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
+            nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
+            nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
+            nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
+
+        if self.text_projection is not None:
+            nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
+
+    def build_attention_mask(self):
+        # lazily create causal attention mask, with full attention between the vision tokens
+        # pytorch uses additive attention mask; fill with -inf
+        mask = torch.empty(self.context_length, self.context_length)
+        mask.fill_(float("-inf"))
+        mask.triu_(1)  # zero out the lower diagonal
+        return mask
+
+    @property
+    def dtype(self):
+        return self.visual.conv1.weight.dtype
+
+    def encode_image(self, image):
+        return self.visual(image.type(self.dtype))
+
+    def get_patch_encodings(self, image) -> torch.Tensor:
+        """ Get the encodings for each patch in the image """
+        return self.visual(image.type(self.dtype), patch_output=True)
+
+    def get_image_encoder_projection(self) -> nn.Parameter:
+        """ Get vision transformer projection matrix."""
+        assert isinstance(self.visual, VisionTransformer)
+        return self.visual.proj
+
+    def encode_text(self, text):
+        x = self.token_embedding(text).type(self.dtype)  # [batch_size, n_ctx, d_model]
+
+        x = x + self.positional_embedding.type(self.dtype)
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+        x = self.ln_final(x).type(self.dtype)
+
+        # x.shape = [batch_size, n_ctx, transformer.width]
+        # take features from the eot embedding (eot_token is the highest number in each sequence)
+        x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
+
+        return x
+
+    def forward(self, image, text):
+        image_features = self.encode_image(image)
+        text_features = self.encode_text(text)
+
+        # normalized features
+        image_features = image_features / image_features.norm(dim=1, keepdim=True)
+        text_features = text_features / text_features.norm(dim=1, keepdim=True)
+
+        # cosine similarity as logits
+        logit_scale = self.logit_scale.exp()
+        logits_per_image = logit_scale * image_features @ text_features.t()
+        logits_per_text = logits_per_image.t()
+
+        # shape = [global_batch_size, global_batch_size]
+        return logits_per_image, logits_per_text
+
+
+def convert_weights(model: nn.Module):
+    """Convert applicable model parameters to fp16"""
+
+    def _convert_weights_to_fp16(l):
+        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
+            l.weight.data = l.weight.data.half()
+            if l.bias is not None:
+                l.bias.data = l.bias.data.half()
+
+        if isinstance(l, nn.MultiheadAttention):
+            for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
+                tensor = getattr(l, attr)
+                if tensor is not None:
+                    tensor.data = tensor.data.half()
+
+        for name in ["text_projection", "proj"]:
+            if hasattr(l, name):
+                attr = getattr(l, name)
+                if attr is not None:
+                    attr.data = attr.data.half()
+
+    model.apply(_convert_weights_to_fp16)
+
+
+def build_model(state_dict: dict):
+    vit = "visual.proj" in state_dict
+
+    if vit:
+        vision_width = state_dict["visual.conv1.weight"].shape[0]
+        vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
+        vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
+        grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
+        image_resolution = vision_patch_size * grid_size
+    else:
+        counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
+        vision_layers = tuple(counts)
+        vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
+        output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
+        vision_patch_size = None
+        assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
+        image_resolution = output_width * 32
+
+    embed_dim = state_dict["text_projection"].shape[1]
+    context_length = state_dict["positional_embedding"].shape[0]
+    vocab_size = state_dict["token_embedding.weight"].shape[0]
+    transformer_width = state_dict["ln_final.weight"].shape[0]
+    transformer_heads = transformer_width // 64
+    transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks")))
+
+    model = CLIP(
+        embed_dim,
+        image_resolution, vision_layers, vision_width, vision_patch_size,
+        context_length, vocab_size, transformer_width, transformer_heads, transformer_layers
+    )
+
+    for key in ["input_resolution", "context_length", "vocab_size"]:
+        if key in state_dict:
+            del state_dict[key]
+
+    convert_weights(model)
+    model.load_state_dict(state_dict)
+    return model.eval()

experimental/SimFeatUp/featup/featurizers/modules/layers.py

@@ -0,0 +1,309 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from functools import partial
+import math
+
+__all__ = ['forward_hook', 'AdaptiveAvgPool2d', 'Add', 'AvgPool2d', 'BatchNorm2d', 'Clone', 'Conv2d', 'ConvTranspose2d',
+           'Dropout', 'Identity', 'LeakyReLU', 'Linear', 'MaxPool2d', 'Multiply', 'ReLU', 'Sequential', 'safe_divide',
+           'ZeroPad2d', 'LayerNorm', 'GELU', 'einsum', 'Softmax']
+
+
+def safe_divide(a, b):
+    return a / (b + b.eq(0).type(b.type()) * 1e-9) * b.ne(0).type(b.type())
+
+
+def forward_hook(self, input, output):
+    if type(input[0]) in (list, tuple):
+        self.X = []
+        for i in input[0]:
+            x = i.detach()
+            x.requires_grad = True
+            self.X.append(x)
+    else:
+        self.X = input[0].detach()
+        self.X.requires_grad = True
+
+    self.Y = output
+
+
+class RelProp(nn.Module):
+    def __init__(self):
+        super(RelProp, self).__init__()
+        # if not self.training:
+        self.register_forward_hook(forward_hook)
+
+    def gradprop(self, Z, X, S):
+        C = torch.autograd.grad(Z, X, S, retain_graph=True)
+        return C
+
+    def relprop(self, R, alpha=1):
+        return R
+
+
+class RelPropSimple(RelProp):
+    def relprop(self, R, alpha=1):
+        Z = self.forward(self.X)
+        S = safe_divide(R, Z)
+        C = self.gradprop(Z, self.X, S)
+
+        if torch.is_tensor(self.X) == False:
+            outputs = []
+            outputs.append(self.X[0] * C[0])
+            outputs.append(self.X[1] * C[1])
+        else:
+            outputs = self.X * C[0]
+        return outputs
+
+
+class Identity(nn.Identity, RelProp):
+    pass
+
+
+class ReLU(nn.ReLU, RelProp):
+    pass
+
+
+class GELU(nn.GELU, RelProp):
+    pass
+
+class LeakyReLU(nn.LeakyReLU, RelProp):
+    pass
+
+class Softmax(nn.Softmax, RelProp):
+    pass
+
+class einsum(RelPropSimple):
+    def __init__(self, equation):
+        super().__init__()
+        self.equation = equation
+    def forward(self, *operands):
+        return torch.einsum(self.equation, *operands)
+
+class Dropout(nn.Dropout, RelProp):
+    pass
+
+
+class MaxPool2d(nn.MaxPool2d, RelPropSimple):
+    pass
+
+class LayerNorm(nn.LayerNorm, RelProp):
+    pass
+
+class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelProp):
+    def relprop(self, R, alpha=1):
+        px = torch.clamp(self.X, min=0)
+
+        def f(x1):
+            Z1 = F.adaptive_avg_pool2d(x1, self.output_size)
+            S1 = safe_divide(R, Z1)
+            C1 = x1 * self.gradprop(Z1, x1, S1)[0]
+            return C1
+
+        activator_relevances = f(px)
+        out = activator_relevances
+        return out
+
+
+class ZeroPad2d(nn.ZeroPad2d, RelPropSimple):
+    def relprop(self, R, alpha=1):
+        Z = self.forward(self.X)
+        S = safe_divide(R, Z)
+        C = self.gradprop(Z, self.X, S)
+        outputs = self.X * C[0]
+        return outputs
+
+
+class AvgPool2d(nn.AvgPool2d, RelPropSimple):
+    pass
+
+
+class Add(RelPropSimple):
+    def forward(self, inputs):
+        return torch.add(*inputs)
+
+    def relprop(self, R, alpha):
+        Z = self.forward(self.X)
+        S = safe_divide(R, Z)
+        C = self.gradprop(Z, self.X, S)
+
+        a = self.X[0] * C[0]
+        b = self.X[1] * C[1]
+
+        a_sum = a.sum()
+        b_sum = b.sum()
+
+        a_fact = safe_divide(a_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum()
+        b_fact = safe_divide(b_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum()
+
+        a = a * safe_divide(a_fact, a.sum())
+        b = b * safe_divide(b_fact, b.sum())
+
+        outputs = [a, b]
+
+        return outputs
+
+
+class Clone(RelProp):
+    def forward(self, input, num):
+        self.__setattr__('num', num)
+        outputs = []
+        for _ in range(num):
+            outputs.append(input)
+
+        return outputs
+
+    def relprop(self, R, alpha = 1):
+        Z = []
+        for _ in range(self.num):
+            Z.append(self.X)
+        S = [safe_divide(r, z) for r, z in zip(R, Z)]
+        C = self.gradprop(Z, self.X, S)[0]
+
+        R = self.X * C
+
+        return R
+
+
+class Multiply(RelPropSimple):
+    def forward(self, inputs):
+        return torch.mul(*inputs)
+
+    def relprop(self, R, alpha=1):
+        x0 = torch.clamp(self.X[0], min=0)
+        x1 = torch.clamp(self.X[1], min=0)
+        x = [x0, x1]
+        Z = self.forward(x)
+        S = safe_divide(R, Z)
+        C = self.gradprop(Z, x, S)
+        outputs = []
+        outputs.append(x[0] * C[0])
+        outputs.append(x[1] * C[1])
+        return outputs
+
+class Sequential(nn.Sequential):
+    def relprop(self, R, alpha=1):
+        for m in reversed(self._modules.values()):
+            R = m.relprop(R, alpha)
+        return R
+
+
+
+class BatchNorm2d(nn.BatchNorm2d, RelProp):
+    def relprop(self, R, alpha=1):
+        X = self.X
+        beta = 1 - alpha
+        weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / (
+            (self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + self.eps).pow(0.5))
+        Z = X * weight + 1e-9
+        S = R / Z
+        Ca = S * weight
+        R = self.X * (Ca)
+        return R
+
+
+class Linear(nn.Linear, RelProp):
+    def relprop(self, R, alpha=1):
+        beta = alpha - 1
+        pw = torch.clamp(self.weight, min=0)
+        nw = torch.clamp(self.weight, max=0)
+        px = torch.clamp(self.X, min=0)
+        nx = torch.clamp(self.X, max=0)
+
+        # def f(w1, w2, x1, x2):
+        #     Z1 = F.linear(x1, w1)
+        #     Z2 = F.linear(x2, w2)
+        #     S1 = safe_divide(R, Z1)
+        #     S2 = safe_divide(R, Z2)
+        #     C1 = x1 * self.gradprop(Z1, x1, S1)[0]
+        #     C2 = x2 * self.gradprop(Z2, x2, S2)[0]
+        #     return C1 #+ C2
+
+        def f(w1, w2, x1, x2):
+            Z1 = F.linear(x1, w1)
+            Z2 = F.linear(x2, w2)
+            Z = Z1 + Z2
+            S = safe_divide(R, Z)
+            C1 = x1 * self.gradprop(Z1, x1, S)[0]
+            C2 = x2 * self.gradprop(Z2, x2, S)[0]
+            return C1 + C2
+
+        activator_relevances = f(pw, nw, px, nx)
+        inhibitor_relevances = f(nw, pw, px, nx)
+
+        out = alpha * activator_relevances - beta * inhibitor_relevances
+
+        return out
+
+
+
+class Conv2d(nn.Conv2d, RelProp):
+
+    def relprop(self, R, alpha=1):
+        if self.X.shape[1] == 3:
+            pw = torch.clamp(self.weight, min=0)
+            nw = torch.clamp(self.weight, max=0)
+            X = self.X
+            L = self.X * 0 + \
+                torch.min(torch.min(torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True)[0], dim=3,
+                          keepdim=True)[0]
+            H = self.X * 0 + \
+                torch.max(torch.max(torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True)[0], dim=3,
+                          keepdim=True)[0]
+            Za = torch.conv2d(X, self.weight, bias=None, stride=self.stride, padding=self.padding) - \
+                 torch.conv2d(L, pw, bias=None, stride=self.stride, padding=self.padding) - \
+                 torch.conv2d(H, nw, bias=None, stride=self.stride, padding=self.padding) + 1e-9
+
+            S = R / Za
+            C = X * self.gradprop2(S, self.weight) - L * self.gradprop2(S, pw) - H * self.gradprop2(S, nw)
+            R = C
+        else:
+            beta = alpha - 1
+            pw = torch.clamp(self.weight, min=0)
+            nw = torch.clamp(self.weight, max=0)
+            px = torch.clamp(self.X, min=0)
+            nx = torch.clamp(self.X, max=0)
+
+            def f(w1, w2, x1, x2):
+                Z1 = F.conv2d(x1, w1, bias=self.bias, stride=self.stride, padding=self.padding, groups=self.groups)
+                Z2 = F.conv2d(x2, w2, bias=self.bias, stride=self.stride, padding=self.padding, groups=self.groups)
+                Z = Z1 + Z2
+                S = safe_divide(R, Z)
+                C1 = x1 * self.gradprop(Z1, x1, S)[0]
+                C2 = x2 * self.gradprop(Z2, x2, S)[0]
+                return C1 + C2
+
+            activator_relevances = f(pw, nw, px, nx)
+            inhibitor_relevances = f(nw, pw, px, nx)
+
+            R = alpha * activator_relevances - beta * inhibitor_relevances
+        return R
+
+
+
+class ConvTranspose2d(nn.ConvTranspose2d, RelProp):
+    def relprop(self, R, alpha=1):
+        pw = torch.clamp(self.weight, min=0)
+        px = torch.clamp(self.X, min=0)
+
+        def f(w1, x1):
+            Z1 = F.conv_transpose2d(x1, w1, bias=None, stride=self.stride, padding=self.padding,
+                                    output_padding=self.output_padding)
+            S1 = safe_divide(R, Z1)
+            C1 = x1 * self.gradprop(Z1, x1, S1)[0]
+            return C1
+
+        activator_relevances = f(pw, px)
+        R = activator_relevances
+        return R
+
+
+
+if __name__ == '__main__':
+    convt = ConvTranspose2d(100, 50, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False).cuda()
+
+    rand = torch.rand((1, 100, 224, 224)).cuda()
+    out = convt(rand)
+    rel = convt.relprop(out)
+
+    print(out.shape)

experimental/SimFeatUp/featup/featurizers/modules/resnet.py

@@ -0,0 +1,339 @@
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as model_zoo
+
+from featup.featurizers.modules.layers import *
+import torch
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152']
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                  padding=1, bias=False)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.clone = Clone()
+
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = BatchNorm2d(planes)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+        self.relu1 = ReLU(inplace=True)
+        self.relu2 = ReLU(inplace=True)
+
+        self.add = Add()
+
+        self.register_forward_hook(forward_hook)
+
+    def forward(self, x):
+        x1, x2 = self.clone(x, 2)
+
+        out = self.conv1(x1)
+        out = self.bn1(out)
+        out = self.relu1(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            x2 = self.downsample(x2)
+
+        out = self.add([out, x2])
+        out = self.relu2(out)
+
+        return out
+
+    def relprop(self, R, alpha):
+        out = self.relu2.relprop(R, alpha)
+        out, x2 = self.add.relprop(out, alpha)
+
+        if self.downsample is not None:
+            x2 = self.downsample.relprop(x2, alpha)
+
+        out = self.bn2.relprop(out, alpha)
+        out = self.conv2.relprop(out, alpha)
+
+        out = self.relu1.relprop(out, alpha)
+        out = self.bn1.relprop(out, alpha)
+        x1 = self.conv1.relprop(out, alpha)
+
+        return self.clone.relprop([x1, x2], alpha)
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+
+        self.conv1 = conv1x1(inplanes, planes)
+        self.bn1 = BatchNorm2d(planes)
+        self.conv2 = conv3x3(planes, planes, stride)
+        self.bn2 = BatchNorm2d(planes)
+        self.conv3 = conv1x1(planes, planes * self.expansion)
+        self.bn3 = BatchNorm2d(planes * self.expansion)
+        self.downsample = downsample
+        self.stride = stride
+
+        self.relu1 = ReLU(inplace=True)
+        self.relu2 = ReLU(inplace=True)
+        self.relu3 = ReLU(inplace=True)
+
+        self.add = Add()
+
+        self.register_forward_hook(forward_hook)
+
+    def forward(self, x):
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu1(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu2(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            x = self.downsample(x)
+
+        out = self.add([out, x])
+        out = self.relu3(out)
+
+        return out
+
+    def relprop(self, R, alpha):
+        out = self.relu3.relprop(R, alpha)
+
+        out, x = self.add.relprop(out, alpha)
+
+        if self.downsample is not None:
+            x = self.downsample.relprop(x, alpha)
+
+        out = self.bn3.relprop(out, alpha)
+        out = self.conv3.relprop(out, alpha)
+
+        out = self.relu2.relprop(out, alpha)
+        out = self.bn2.relprop(out, alpha)
+        out = self.conv2.relprop(out, alpha)
+
+        out = self.relu1.relprop(out, alpha)
+        out = self.bn1.relprop(out, alpha)
+        x1 = self.conv1.relprop(out, alpha)
+
+        return x1 + x
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, long=False, zero_init_residual=False):
+        super(ResNet, self).__init__()
+        self.inplanes = 64
+        self.conv1 = Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
+        self.bn1 = BatchNorm2d(64)
+        self.relu = ReLU(inplace=True)
+        self.maxpool = MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.avgpool = AdaptiveAvgPool2d((1, 1))
+        self.fc = Linear(512 * block.expansion, num_classes)
+        self.long = long
+        self.num_classes = num_classes
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return Sequential(*layers)
+
+    def CLRP(self, x):
+        maxindex = torch.argmax(x, dim=1)
+        R = torch.ones(x.shape, device=x.device)
+        R /= -self.num_classes
+        for i in range(R.size(0)):
+            R[i, maxindex[i]] = 1
+        return R
+
+    def forward(self, img):
+        x = self.conv1(img)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+        layer1 = self.layer1(x)
+        layer2 = self.layer2(layer1)
+        layer3 = self.layer3(layer2)
+        layer4 = self.layer4(layer3)
+
+        x = self.avgpool(layer4)
+        x = x.view(x.size(0), -1)
+        return self.fc(x)
+
+    def get_layer(self, img, layer_num):
+        x = self.conv1(img)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+        layer1 = self.layer1(x)
+        if layer_num == 1:
+            return layer1
+        layer2 = self.layer2(layer1)
+        if layer_num == 2:
+            return layer2
+        layer3 = self.layer3(layer2)
+        if layer_num == 3:
+            return layer3
+        layer4 = self.layer4(layer3)
+        if layer_num == 4 or layer_num == -1:
+            return layer4
+        if isinstance(layer_num, tuple):
+            return [[layer1, layer2, layer3, layer4][i-1] for i in layer_num]
+
+        raise ValueError(f"Unknown layer num: {layer_num}")
+
+    def relevance_cam(self, large_img, layer_num, upsampler):
+        small_img = F.interpolate(large_img, size=(224, 224), mode='bilinear')
+        layer1, layer2, layer3, layer4 = self.get_layer(small_img, (1, 2, 3, 4))
+        x = self.avgpool(layer4)
+        x = x.view(x.size(0), -1)
+        z = self.fc(x)
+
+        R = self.CLRP(z)
+        R = self.fc.relprop(R, 1)
+        R = R.reshape_as(self.avgpool.Y)
+        R4 = self.avgpool.relprop(R, 1)
+
+        if layer_num == 4:
+            r_weight4 = torch.mean(R4, dim=(2, 3), keepdim=True)
+            r_cam4 = upsampler(large_img, source=layer4) * r_weight4
+            r_cam4 = torch.sum(r_cam4, dim=(1), keepdim=True)
+            return r_cam4
+        elif layer_num == 3:
+            R3 = self.layer4.relprop(R4, 1)
+            r_weight3 = torch.mean(R3, dim=(2, 3), keepdim=True)
+            r_cam3 = upsampler(large_img, source=layer3) * r_weight3
+            r_cam3 = torch.sum(r_cam3, dim=(1), keepdim=True)
+            return r_cam3
+        elif layer_num == 2:
+            R3 = self.layer4.relprop(R4, 1)
+            R2 = self.layer3.relprop(R3, 1)
+            r_weight2 = torch.mean(R2, dim=(2, 3), keepdim=True)
+            r_cam2 = upsampler(large_img, source=layer2) * r_weight2
+            r_cam2 = torch.sum(r_cam2, dim=(1), keepdim=True)
+            return r_cam2
+        else:
+            raise ValueError(f"Unknown layer_num: {layer_num}")
+
+
+def resnet18(pretrained=False, **kwargs):
+    """Constructs a ResNet-18 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
+    return model
+
+
+def resnet34(pretrained=False, **kwargs):
+    """Constructs a ResNet-34 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
+    return model
+
+
+def resnet50(pretrained=False, long=False, **kwargs):
+    """Constructs a ResNet-50 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3], long=long, **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
+    return model
+
+
+def resnet101(pretrained=False, **kwargs):
+    """Constructs a ResNet-101 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
+    return model
+
+
+def resnet152(pretrained=False, **kwargs):
+    """Constructs a ResNet-152 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
+    return model

experimental/SimFeatUp/featup/featurizers/modules/vgg.py

@@ -0,0 +1,366 @@
+import copy
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as model_zoo
+import torch
+from featup.featurizers.modules.layers import *
+
+__all__ = [
+    'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
+    'vgg19_bn', 'vgg19',
+]
+
+
+model_urls = {
+    'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
+    'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
+    'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
+    'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
+    'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
+    'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
+    'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
+    'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
+}
+
+class VGG_spread(nn.Module):
+
+    def __init__(self, features, num_classes=1000, init_weights=True):
+        super(VGG_spread, self).__init__()
+        self.features = features
+        self.avgpool = AdaptiveAvgPool2d((7, 7))
+        self.classifier = Sequential(
+            Linear(512 * 7 * 7, 4096),
+            ReLU(True),
+            Dropout(),
+            Linear(4096, 4096),
+            ReLU(True),
+            Dropout(),
+            Linear(4096, num_classes),
+        )
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        for layer in self.features:
+            x = layer(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+    def relprop(self, R, alpha):
+        x = self.classifier.relprop(R, alpha)
+        x = x.reshape_as(next(reversed(self.features._modules.values())).Y)
+        x = self.avgpool.relprop(x, alpha)
+        x = self.features.relprop(x, alpha)
+        return x
+
+    def m_relprop(self, R, pred, alpha):
+        x = self.classifier.m_relprop(R, pred, alpha)
+        if torch.is_tensor(x) == False:
+            for i in range(len(x)):
+                x[i] = x[i].reshape_as(next(reversed(self.features._modules.values())).Y)
+        else:
+            x = x.reshape_as(next(reversed(self.features._modules.values())).Y)
+        x = self.avgpool.m_relprop(x, pred, alpha)
+        x = self.features.m_relprop(x, pred, alpha)
+        return x
+
+    def RAP_relprop(self, R):
+        x1 = self.classifier.RAP_relprop(R)
+        if torch.is_tensor(x1) == False:
+            for i in range(len(x1)):
+                x1[i] = x1[i].reshape_as(next(reversed(self.features._modules.values())).Y)
+        else:
+            x1 = x1.reshape_as(next(reversed(self.features._modules.values())).Y)
+        x1 = self.avgpool.RAP_relprop(x1)
+        x1 = self.features.RAP_relprop(x1)
+        return x1
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+
+
+class VGG(nn.Module):
+
+    def __init__(self, features, num_classes=1000, init_weights=True):
+        super(VGG, self).__init__()
+        self.features = features
+        self.avgpool = AdaptiveAvgPool2d((7, 7))
+        self.classifier = Sequential(
+            Linear(512 * 7 * 7, 4096),
+            ReLU(True),
+            Dropout(),
+            Linear(4096, 4096),
+            ReLU(True),
+            Dropout(),
+            Linear(4096, num_classes),
+        )
+        self.num_classes = num_classes
+        if init_weights:
+            self._initialize_weights()
+
+    def CLRP(self, x, maxindex = [None]):
+        if maxindex == [None]:
+            maxindex = torch.argmax(x, dim=1)
+        R = torch.ones(x.shape, x.device)
+        R /= -self.num_classes
+        for i in range(R.size(0)):
+            R[i, maxindex[i]] = 1
+        return R
+
+    def upsample(self, source, guidance_unscaled, upsampler, scale):
+        _, _, H, W = source.shape
+        guidance = F.interpolate(guidance_unscaled, size=(H * scale, W * scale), mode='bilinear')
+        return upsampler(source, guidance)
+
+    def forward(self, x,mode='output', target_class = [None], upsampler=None, scale=1):
+        inp = copy.deepcopy(x)
+        for i, layer in enumerate(self.features):
+            x = layer(x)
+            if mode.lstrip('-').isnumeric():
+                if int(mode) == i:
+                    target_layer = x
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+
+        if mode == 'output':
+            return x
+
+        R = self.CLRP(x, target_class)
+        R = self.classifier.relprop(R)
+        R = R.reshape_as(next(reversed(self.features._modules.values())).Y)
+        R = self.avgpool.relprop(R)
+
+        for i in range(len(self.features)-1, int(mode), -1):
+            R = self.features[i].relprop(R)
+
+        if upsampler is not None:
+            target_layer = self.upsample(target_layer, inp, upsampler, scale)
+
+        r_weight = torch.mean(R, dim=(2, 3), keepdim=True)
+        r_cam = target_layer * r_weight
+        r_cam = torch.sum(r_cam, dim=(1), keepdim=True)
+        return r_cam, x
+
+
+
+    def relprop(self, R, alpha, flag=-1):
+        x = self.classifier.relprop(R, alpha)
+        x = x.reshape_as(next(reversed(self.features._modules.values())).Y)
+        x = self.avgpool.relprop(x, alpha)
+        # x = self.features.relprop(x, alpha)
+        for i in range(43, flag, -1):
+            x = self.features[i].relprop(x, alpha)
+        return x
+
+    def m_relprop(self, R, pred, alpha):
+        x = self.classifier.m_relprop(R, pred, alpha)
+        if torch.is_tensor(x) == False:
+            for i in range(len(x)):
+                x[i] = x[i].reshape_as(next(reversed(self.features._modules.values())).Y)
+        else:
+            x = x.reshape_as(next(reversed(self.features._modules.values())).Y)
+        x = self.avgpool.m_relprop(x, pred, alpha)
+        x = self.features.m_relprop(x, pred, alpha)
+        return x
+
+    def RAP_relprop(self, R):
+        x1 = self.classifier.RAP_relprop(R)
+        if torch.is_tensor(x1) == False:
+            for i in range(len(x1)):
+                x1[i] = x1[i].reshape_as(next(reversed(self.features._modules.values())).Y)
+        else:
+            x1 = x1.reshape_as(next(reversed(self.features._modules.values())).Y)
+        x1 = self.avgpool.RAP_relprop(x1)
+        x1 = self.features.RAP_relprop(x1)
+
+        return x1
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+
+def make_layers(cfg, batch_norm=False):
+    layers = []
+    in_channels = 3
+
+    for v in cfg:
+        if v == 'M':
+            layers += [MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = Conv2d(in_channels, v, kernel_size=3, padding=1)
+            if batch_norm:
+                layers += [conv2d, BatchNorm2d(v), ReLU(inplace=True)]
+            else:
+                layers += [conv2d, ReLU(inplace=True)]
+            in_channels = v
+
+    return Sequential(*layers)
+
+def make_layers_list(cfg, batch_norm=False):
+    layers = []
+    in_channels = 3
+    for v in cfg:
+        if v == 'M':
+            layers += [MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = Conv2d(in_channels, v, kernel_size=3, padding=1)
+            if batch_norm:
+                layers += [conv2d, BatchNorm2d(v), ReLU(inplace=True)]
+            else:
+                layers += [conv2d, ReLU(inplace=True)]
+            in_channels = v
+    return layers
+
+
+cfg = {
+    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
+    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
+}
+
+
+def vgg11(pretrained=False, **kwargs):
+    """VGG 11-layer model (configuration "A")
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['A']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg11']))
+    return model
+
+
+def vgg11_bn(pretrained=False, **kwargs):
+    """VGG 11-layer model (configuration "A") with batch normalization
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['A'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg11_bn']))
+    return model
+
+
+def vgg13(pretrained=False, **kwargs):
+    """VGG 13-layer model (configuration "B")
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['B']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg13']))
+    return model
+
+
+def vgg13_bn(pretrained=False, **kwargs):
+    """VGG 13-layer model (configuration "B") with batch normalization
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['B'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg13_bn']))
+    return model
+
+
+def vgg16(pretrained=False, **kwargs):
+    """VGG 16-layer model (configuration "D")
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['D']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg16']))
+    return model
+
+def vgg16_spread(pretrained=False, **kwargs):
+    """VGG 16-layer model (configuration "D")
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG_spread(make_layers_list(cfg['D']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg16']))
+    return model
+
+def vgg16_bn(pretrained=False, **kwargs):
+    """VGG 16-layer model (configuration "D") with batch normalization
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg16_bn']))
+    return model
+
+
+def vgg19(pretrained=False, **kwargs):
+    """VGG 19-layer model (configuration "E")
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['E']), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg19']))
+    return model
+
+
+def vgg19_bn(pretrained=False, **kwargs):
+    """VGG 19-layer model (configuration 'E') with batch normalization
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfg['E'], batch_norm=True), **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['vgg19_bn']))
+    return model

experimental/build_env/declip/download_eva_clip.sh

@@ -0,0 +1,284 @@
+#!/bin/bash
+# DeCLIP 环境构建脚本
+# 下载 EVA-CLIP、I-JEPA 预训练权重和 COCO 数据集到 /opt/tiger/xiaomoguhzz/
+
+set -e
+
+# 在任意 cd 之前解析脚本所在目录和项目根目录，避免后续 cd 导致 PROJECT_DIR 错误
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$(dirname "${SCRIPT_DIR}")")"
+
+BASE_DIR="/opt/tiger/xiaomoguhzz"
+COCO_DIR="${BASE_DIR}/standard_coco"
+IJEPA_DIR="${BASE_DIR}/ijepa"
+
+# 创建目录
+mkdir -p "${BASE_DIR}"
+mkdir -p "${COCO_DIR}"
+mkdir -p "${IJEPA_DIR}"
+
+echo "================================================"
+echo "DeCLIP 环境构建脚本"
+echo "目标目录: ${BASE_DIR}"
+echo "================================================"
+
+# ==================== EVA-CLIP 权重下载 ====================
+echo ""
+echo "[1/4] 下载 EVA-CLIP 预训练权重..."
+echo "------------------------------------------------"
+
+if [ -f "${BASE_DIR}/EVA02_CLIP_L_336_psz14_s6B.pt" ]; then
+    echo "EVA02_CLIP_L_336_psz14_s6B.pt 已存在，跳过下载"
+else
+    echo "正在下载 EVA02_CLIP_L_336_psz14_s6B.pt..."
+    huggingface-cli download QuanSun/EVA-CLIP EVA02_CLIP_L_336_psz14_s6B.pt --local-dir "${BASE_DIR}" --local-dir-use-symlinks False
+fi
+
+if [ -f "${BASE_DIR}/EVA02_CLIP_B_psz16_s8B.pt" ]; then
+    echo "EVA02_CLIP_B_psz16_s8B.pt 已存在，跳过下载"
+else
+    echo "正在下载 EVA02_CLIP_B_psz16_s8B.pt..."
+    huggingface-cli download QuanSun/EVA-CLIP EVA02_CLIP_B_psz16_s8B.pt --local-dir "${BASE_DIR}" --local-dir-use-symlinks False
+fi
+
+echo "EVA-CLIP 权重下载完成！"
+
+# ==================== CLIPSelf proposals 权重下载 ====================
+echo ""
+echo "[1.2/4] 下载 CLIPSelf proposals 权重..."
+echo "------------------------------------------------"
+
+if [ -f "${BASE_DIR}/fvit_eva_vitb16_ovcoco_clipself_proposals.pth" ]; then
+    echo "fvit_eva_vitb16_ovcoco_clipself_proposals.pth 已存在，跳过下载"
+else
+    echo "正在下载 fvit_eva_vitb16_ovcoco_clipself_proposals.pth..."
+    huggingface-cli download xiaomoguhzz/xiaomogu_pami fvit_eva_vitb16_ovcoco_clipself_proposals.pth --repo-type model --local-dir "${BASE_DIR}"
+fi
+
+if [ -f "${BASE_DIR}/fvit_eva_vitl14_ovcoco_clipself_proposals.pth" ]; then
+    echo "fvit_eva_vitl14_ovcoco_clipself_proposals.pth 已存在，跳过下载"
+else
+    echo "正在下载 fvit_eva_vitl14_ovcoco_clipself_proposals.pth..."
+    huggingface-cli download xiaomoguhzz/xiaomogu_pami fvit_eva_vitl14_ovcoco_clipself_proposals.pth --repo-type model --local-dir "${BASE_DIR}"
+fi
+
+echo "CLIPSelf proposals 权重下载完成！"
+
+# ==================== SAM 权重下载 ====================
+echo ""
+echo "[1.5/4] 下载 SAM 预训练权重..."
+echo "------------------------------------------------"
+
+if [ -f "${BASE_DIR}/sam_vit_l_0b3195.pth" ]; then
+    echo "sam_vit_l_0b3195.pth 已存在，跳过下载"
+else
+    echo "正在下载 SAM-L (约 1.25GB)..."
+    wget -c https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth -O "${BASE_DIR}/sam_vit_l_0b3195.pth"
+fi
+
+if [ -f "${BASE_DIR}/sam_vit_b_01ec64.pth" ]; then
+    echo "sam_vit_b_01ec64.pth 已存在，跳过下载"
+else
+    echo "正在下载 SAM-B (约 375MB)..."
+    wget -c https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth -O "${BASE_DIR}/sam_vit_b_01ec64.pth"
+fi
+
+echo "SAM 权重下载完成！"
+
+# ==================== I-JEPA 权重下载 ====================
+echo ""
+echo "[2/4] 下载 I-JEPA 预训练权重..."
+echo "------------------------------------------------"
+
+if [ -f "${IJEPA_DIR}/IN1K-vit.h.14-300e.pth.tar" ]; then
+    echo "IN1K-vit.h.14-300e.pth.tar 已存在，跳过下载"
+else
+    echo "正在下载 I-JEPA ViT-H/14 (224x224, ~9.7GB)..."
+    wget -c https://dl.fbaipublicfiles.com/ijepa/IN1K-vit.h.14-300e.pth.tar -O "${IJEPA_DIR}/IN1K-vit.h.14-300e.pth.tar"
+fi
+
+if [ -f "${IJEPA_DIR}/IN1K-vit.h.16-448px-300e.pth.tar" ]; then
+    echo "IN1K-vit.h.16-448px-300e.pth.tar 已存在，跳过下载"
+else
+    echo "正在下载 I-JEPA ViT-H/16 (448x448, ~9.7GB)..."
+    wget -c https://dl.fbaipublicfiles.com/ijepa/IN1K-vit.h.16-448px-300e.pth.tar -O "${IJEPA_DIR}/IN1K-vit.h.16-448px-300e.pth.tar"
+fi
+
+echo "I-JEPA 权重下载完成！"
+
+# ==================== COCO 数据集下载 ====================
+echo ""
+echo "[3/4] 下载 COCO 数据集..."
+echo "------------------------------------------------"
+
+cd "${COCO_DIR}"
+
+# 定义下载函数
+download_and_extract() {
+    local url=$1
+    local zip_name=$2
+    local check_file=$3
+    
+    if [ -f "${check_file}" ] || [ -d "${check_file}" ]; then
+        echo "${zip_name} 相关文件已存在，跳过"
+        return 0
+    fi
+    
+    if [ ! -f "${zip_name}" ]; then
+        echo "正在下载 ${zip_name}..."
+        wget -c "${url}"
+    fi
+    
+    echo "正在解压 ${zip_name}..."
+    unzip -o -q "${zip_name}"
+    rm -f "${zip_name}"
+}
+
+# 检查图像目录是否完整 (train2017 应有 118287 张, val2017 应有 5000 张)
+check_images_exist() {
+    local dir=$1
+    local min_count=$2
+    if [ -d "${dir}" ]; then
+        local count=$(ls "${dir}" 2>/dev/null | wc -l)
+        if [ "${count}" -ge "${min_count}" ]; then
+            return 0
+        fi
+    fi
+    return 1
+}
+
+# 下载标注文件
+if [ -f "${COCO_DIR}/annotations/instances_train2017.json" ]; then
+    echo "annotations_trainval2017 已存在，跳过"
+else
+    download_and_extract "http://images.cocodataset.org/annotations/annotations_trainval2017.zip" "annotations_trainval2017.zip" "${COCO_DIR}/annotations/instances_train2017.json"
+fi
+
+if [ -f "${COCO_DIR}/annotations/panoptic_val2017.json" ]; then
+    echo "panoptic_annotations 已存在，跳过"
+else
+    download_and_extract "http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip" "panoptic_annotations_trainval2017.zip" "${COCO_DIR}/annotations/panoptic_val2017.json"
+    # 解压内部的 panoptic 分割图像 zip
+    cd "${COCO_DIR}/annotations"
+    if [ -f "panoptic_val2017.zip" ]; then
+        echo "正在解压 panoptic_val2017.zip..."
+        unzip -o -q panoptic_val2017.zip &
+    fi
+    if [ -f "panoptic_train2017.zip" ]; then
+        echo "正在解压 panoptic_train2017.zip..."
+        unzip -o -q panoptic_train2017.zip &
+    fi
+    wait
+    rm -f panoptic_val2017.zip panoptic_train2017.zip 2>/dev/null
+    cd "${COCO_DIR}"
+fi
+
+# 并行下载和解压图像（如果需要）
+NEED_TRAIN=false
+NEED_VAL=false
+
+if check_images_exist "${COCO_DIR}/train2017" 100000; then
+    echo "train2017 已存在 ($(ls ${COCO_DIR}/train2017 | wc -l) 张图像)，跳过"
+else
+    NEED_TRAIN=true
+fi
+
+if check_images_exist "${COCO_DIR}/val2017" 4000; then
+    echo "val2017 已存在 ($(ls ${COCO_DIR}/val2017 | wc -l) 张图像)，跳过"
+else
+    NEED_VAL=true
+fi
+
+# 并行下载
+if [ "${NEED_TRAIN}" = true ] || [ "${NEED_VAL}" = true ]; then
+    echo "开始并行下载图像..."
+    
+    if [ "${NEED_TRAIN}" = true ] && [ ! -f "train2017.zip" ]; then
+        echo "正在下载 train2017.zip (约 18GB)..."
+        wget -c http://images.cocodataset.org/zips/train2017.zip &
+        TRAIN_PID=$!
+    fi
+    
+    if [ "${NEED_VAL}" = true ] && [ ! -f "val2017.zip" ]; then
+        echo "正在下载 val2017.zip (约 1GB)..."
+        wget -c http://images.cocodataset.org/zips/val2017.zip &
+        VAL_PID=$!
+    fi
+    
+    # 等待下载完成
+    [ -n "${TRAIN_PID}" ] && wait ${TRAIN_PID}
+    [ -n "${VAL_PID}" ] && wait ${VAL_PID}
+    
+    echo "下载完成，开始并行解压..."
+    
+    # 并行解压
+    if [ "${NEED_TRAIN}" = true ] && [ -f "train2017.zip" ]; then
+        echo "正在解压 train2017.zip..."
+        unzip -o -q train2017.zip && rm -f train2017.zip &
+        TRAIN_UNZIP_PID=$!
+    fi
+    
+    if [ "${NEED_VAL}" = true ] && [ -f "val2017.zip" ]; then
+        echo "正在解压 val2017.zip..."
+        unzip -o -q val2017.zip && rm -f val2017.zip &
+        VAL_UNZIP_PID=$!
+    fi
+    
+    # 等待解压完成
+    [ -n "${TRAIN_UNZIP_PID}" ] && wait ${TRAIN_UNZIP_PID}
+    [ -n "${VAL_UNZIP_PID}" ] && wait ${VAL_UNZIP_PID}
+fi
+
+# ==================== 安装依赖和项目 ====================
+echo ""
+echo "[4/4] 安装依赖和 DeCLIP 项目..."
+echo "------------------------------------------------"
+
+# 安装 faiss-cpu (用于特征检索和相似度搜索)
+echo "安装 faiss-cpu..."
+pip install faiss-cpu
+
+# 安装 panopticapi (COCO Panoptic 数据集处理工具)
+echo "安装 panopticapi..."
+pip install git+https://github.com/cocodataset/panopticapi.git
+
+# 安装 tensorboard (训练可视化)
+echo "安装 tensorboard..."
+pip install tensorboard
+
+# 安装 torch 和 xformers (需要匹配版本)
+echo "安装 torch==2.6.0+cu124 和 xformers==0.0.29.post2..."
+pip install torch==2.6.0+cu124 torchvision --index-url https://download.pytorch.org/whl/cu124
+pip install xformers==0.0.29.post2
+
+# 使用脚本开头已解析的项目根目录（避免因前面 cd 到 COCO_DIR 导致 PROJECT_DIR 变成 /opt/tiger）
+cd "${PROJECT_DIR}"
+echo "项目目录: ${PROJECT_DIR}"
+
+# 使用 setup.py 安装项目（包名为 open_clip_torch）
+# 如果 pyproject.toml 存在，先备份
+if [ -f "pyproject.toml" ]; then
+    mv pyproject.toml pyproject.toml.bak
+    echo "已备份 pyproject.toml"
+fi
+
+pip install -e .
+echo "DeCLIP 项目安装完成！（包名: open_clip_torch）"
+
+echo ""
+echo "================================================"
+echo "环境构建完成！"
+echo "================================================"
+echo ""
+echo "EVA-CLIP 权重位置："
+ls -lh "${BASE_DIR}"/EVA02_CLIP_*.pt 2>/dev/null || echo "  (未找到权重文件)"
+echo ""
+echo "I-JEPA 权重位置："
+ls -lh "${IJEPA_DIR}"/*.pth.tar 2>/dev/null || echo "  (未找到权重文件)"
+echo ""
+echo "COCO 数据集结构："
+echo "  ${COCO_DIR}/"
+echo "  ├── annotations/"
+ls "${COCO_DIR}/annotations/" 2>/dev/null | head -10 | sed 's/^/  │   ├── /'
+echo "  ├── train2017/ ($(ls ${COCO_DIR}/train2017 2>/dev/null | wc -l) 张图像)"
+echo "  └── val2017/ ($(ls ${COCO_DIR}/val2017 2>/dev/null | wc -l) 张图像)"

experimental/build_env/declip/install_mmcv_mmdet.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# 安装 mmcv-full 1.7.2 和 mmdetection v2.28.1
+# 用于 F-ViT OV-COCO 检测评估
+# 环境要求: PyTorch 2.6.x + CUDA 12.4
+
+set -e
+
+INSTALL_DIR=/opt/tiger/xiaomoguhzz
+
+echo "=========================================="
+echo "Installing mmcv-full 1.7.2 and mmdetection v2.28.1"
+echo "Install directory: ${INSTALL_DIR}"
+echo "=========================================="
+
+# Step 1: 安装 mmcv-full 1.7.2 (预编译包)
+echo "Installing mmcv-full 1.7.2 via pip..."
+pip install mmcv-full==1.7.2 -f https://download.openmmlab.com/mmcv/dist/cu124/torch2.6/index.html
+
+# Step 2: 安装 mmdetection v2.28.1
+cd ${INSTALL_DIR}
+
+if [ -d "mmdetection" ]; then
+    echo "mmdetection directory exists, skipping clone..."
+else
+    echo "Cloning mmdetection..."
+    git clone https://github.com/open-mmlab/mmdetection.git
+fi
+
+cd mmdetection
+git checkout v2.28.1
+
+echo "Installing mmdetection..."
+pip install -e . -v
+
+echo "=========================================="
+echo "Installation complete!"
+echo "mmcv-full: 1.7.2 (pip installed)"
+echo "mmdetection: ${INSTALL_DIR}/mmdetection"
+echo "=========================================="
+
+# Step 3: 应用 PyTorch 2.6.0 兼容性修复
+echo ""
+echo "Applying PyTorch 2.6.0 compatibility fix..."
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "${SCRIPT_DIR}/../fix_mmcv_pytorch26.sh" ]; then
+    bash "${SCRIPT_DIR}/../fix_mmcv_pytorch26.sh"
+else
+    echo "Warning: fix_mmcv_pytorch26.sh not found, skipping compatibility fix"
+    echo "If you encounter '_use_replicated_tensor_module' errors, run:"
+    echo "  bash ${SCRIPT_DIR}/../fix_mmcv_pytorch26.sh"
+fi
+
+echo ""
+echo "=========================================="
+echo "Installation and fixes complete!"
+echo "=========================================="
+
+# 验证安装
+echo "Verifying installation..."
+python -c "from mmcv.ops import nms; print('CUDA ops OK'); import mmcv; print(f'mmcv version: {mmcv.__version__}')"
+python -c "import mmdet; print(f'mmdet version: {mmdet.__version__}')"

experimental/build_env/declip/requirements_verified.txt

@@ -0,0 +1,24 @@
+# DeCLIP 验证可行的依赖版本组合
+# 测试环境: Python 3.11, CUDA 12.4
+# 测试日期: 2026-01-18
+
+# 核心深度学习框架
+torch==2.6.0+cu124
+torchvision  # 需与 torch 版本匹配，pip install torchvision --upgrade
+xformers==0.0.29.post2
+flash-attn==2.8.0.post2
+
+# 数值计算
+numpy<2  # scipy/sklearn 需要 numpy 1.x，使用 pip install "numpy<2"
+
+# 数据处理和评估
+faiss-cpu
+tensorboard
+panopticapi @ git+https://github.com/cocodataset/panopticapi.git
+
+# 注意事项:
+# 1. xformers 和 flash-attn 版本需要匹配，否则会报错:
+#    - xformers 0.0.32.post1 要求 flash-attn >=2.7.1,<=2.8.2
+#    - xformers 0.0.29.post2 兼容 flash-attn 2.8.0.post2
+# 2. numpy 2.x 与 scipy/sklearn 不兼容，需降级到 numpy<2
+# 3. 安装项目本身: pip install -e . --no-deps (在项目根目录执行)

experimental/build_env/fix_mmcv_pytorch26.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+# mmcv-full 1.7.2 与 PyTorch 2.6.0 兼容性修复脚本
+# 
+# 问题：MMDistributedDataParallel 缺少 _use_replicated_tensor_module 属性检查
+# 解决：添加 hasattr 检查，确保兼容性
+#
+# 使用方法：
+#   bash fix_mmcv_pytorch26.sh
+
+set -e
+
+echo "========================================"
+echo "mmcv-full 1.7.2 PyTorch 2.6.0 兼容性修复"
+echo "========================================"
+echo ""
+
+# 1. 查找 mmcv 安装路径
+echo "[1/4] 查找 mmcv 安装路径..."
+MMCV_FILE=$(python3 -c "from mmcv.parallel import MMDistributedDataParallel; import inspect; print(inspect.getfile(MMDistributedDataParallel))" 2>/dev/null)
+
+if [ -z "$MMCV_FILE" ]; then
+    echo "❌ 错误：无法找到 mmcv 安装路径"
+    echo "请确保已安装 mmcv-full"
+    exit 1
+fi
+
+echo "✓ 找到 mmcv distributed.py："
+echo "  $MMCV_FILE"
+echo ""
+
+# 2. 备份原文件
+echo "[2/4] 备份原文件..."
+if [ -f "${MMCV_FILE}.bak" ]; then
+    echo "✓ 备份文件已存在，跳过备份"
+else
+    cp "$MMCV_FILE" "${MMCV_FILE}.bak"
+    echo "✓ 备份完成：${MMCV_FILE}.bak"
+fi
+echo ""
+
+# 3. 应用修复
+echo "[3/4] 应用修复..."
+python3 << EOF
+import sys
+
+file_path = "$MMCV_FILE"
+
+# 读取文件
+with open(file_path, 'r') as f:
+    lines = f.readlines()
+
+# 检查是否需要修复
+if len(lines) <= 160:
+    print("❌ 错误：文件行数不足，无法修复")
+    sys.exit(1)
+
+# 检查是否已经修复过
+if 'hasattr(self, ' in lines[160]:
+    print("✓ 文件已经修复过，无需重复修复")
+    sys.exit(0)
+
+# 检查第160行是否包含需要修复的代码
+if 'self._use_replicated_tensor_module' not in lines[160]:
+    print("❌ 警告：第160行代码与预期不符")
+    print("当前第160行内容：")
+    print(lines[160])
+    print("\n可能 mmcv 版本不匹配，请手动检查")
+    sys.exit(1)
+
+# 应用修复
+lines[160] = "            (hasattr(self, '_use_replicated_tensor_module') and self._use_replicated_tensor_module) else self.module\n"
+
+# 写回文件
+with open(file_path, 'w') as f:
+    f.writelines(lines)
+
+print("✓ 修复应用成功")
+EOF
+
+if [ $? -ne 0 ]; then
+    echo ""
+    echo "修复失败，请检查上述错误信息"
+    exit 1
+fi
+echo ""
+
+# 4. 验证修复
+echo "[4/4] 验证修复..."
+echo "修复后的代码（第159-161行）："
+echo "---"
+sed -n '159,161p' "$MMCV_FILE"
+echo "---"
+echo ""
+
+# 检查是否包含 hasattr
+if grep -q "hasattr(self, '_use_replicated_tensor_module')" "$MMCV_FILE"; then
+    echo "✅ 修复验证成功！"
+    echo ""
+    echo "========================================"
+    echo "修复完成！"
+    echo "========================================"
+    echo ""
+    echo "现在可以正常使用多卡分布式训练/推理了"
+    echo ""
+    echo "如需恢复原文件，执行："
+    echo "  cp ${MMCV_FILE}.bak $MMCV_FILE"
+else
+    echo "❌ 修复验证失败"
+    echo "文件已修改，但未检测到预期的 hasattr 检查"
+    exit 1
+fi

experimental/build_env/fix_mmcv_pytorch26_v2.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# 一键修复 mmcv 与 PyTorch 2.6 兼容问题
+# 修复点:
+# 1) mmcv/parallel/_functions.py: int device -> torch.device
+# 2) (可选) mmcv/parallel/distributed.py: _use_replicated_tensor_module 兼容
+
+set -euo pipefail
+
+echo "========================================"
+echo "mmcv + PyTorch 2.6 兼容性修复 (v2)"
+echo "========================================"
+
+# 1) 定位 mmcv 目录
+MMCV_DIR="$(python3 - <<'PY'
+import os
+import sys
+
+def find_mmcv_parallel_path():
+    for p in sys.path:
+        cand = os.path.join(p, "mmcv", "parallel")
+        if os.path.isfile(os.path.join(cand, "_functions.py")):
+            return cand
+    return ""
+
+print(find_mmcv_parallel_path())
+PY
+)"
+
+if [[ -z "${MMCV_DIR}" ]]; then
+  echo "❌ 无法定位 mmcv 安装路径"
+  exit 1
+fi
+
+FUNC_FILE="${MMCV_DIR}/_functions.py"
+DIST_FILE="${MMCV_DIR}/distributed.py"
+
+echo "[1/4] mmcv 路径：${MMCV_DIR}"
+echo "[2/4] 备份文件..."
+
+if [[ -f "${FUNC_FILE}" && ! -f "${FUNC_FILE}.bak" ]]; then
+  cp "${FUNC_FILE}" "${FUNC_FILE}.bak"
+fi
+if [[ -f "${DIST_FILE}" && ! -f "${DIST_FILE}.bak" ]]; then
+  cp "${DIST_FILE}" "${DIST_FILE}.bak"
+fi
+echo "✓ 备份完成"
+
+echo "[3/4] 修复 _functions.py ..."
+python3 - <<PY
+import sys
+import re
+
+func_file = "${FUNC_FILE}"
+with open(func_file, "r") as f:
+    lines = f.readlines()
+
+patched = False
+def _child_indent(idx):
+    j = idx - 1
+    while j >= 0 and lines[j].strip() == "":
+        j -= 1
+    while j >= 0 and not lines[j].rstrip().endswith(":"):
+        j -= 1
+    if j >= 0:
+        base = re.match(r"^\\s*", lines[j]).group(0)
+        return base + ("\\t" if "\\t" in base else "    ")
+    return "        "
+
+def _replace_line(idx):
+    indent = _child_indent(idx)
+    lines[idx] = (indent
+                  + "streams = [_get_stream(torch.device('cuda', d) if isinstance(d, int) else d) "
+                  + "for d in target_gpus]\\n")
+    return True
+
+for i, line in enumerate(lines):
+    if "streams" in line and "_get_stream" in line and "target_gpus" in line:
+        patched = _replace_line(i)
+        break
+
+if not patched:
+    for i, line in enumerate(lines):
+        if "if torch.cuda.is_available()" in line and "target_gpus" in line:
+            j = i + 1
+            while j < len(lines) and lines[j].strip() == "":
+                j += 1
+            if j < len(lines):
+                patched = _replace_line(j)
+            break
+
+if not patched:
+    print("❌ 未找到可替换的 streams 行，请手动检查 _functions.py")
+    sys.exit(1)
+
+if not any(l.strip().startswith("import torch") for l in lines):
+    lines.insert(0, "import torch\\n")
+
+with open(func_file, "w") as f:
+    f.writelines(lines)
+
+print("✓ _functions.py 修复完成")
+PY
+
+echo "[4/4] (可选) 修复 distributed.py ..."
+python3 - <<PY
+dist_file = "${DIST_FILE}"
+with open(dist_file, "r") as f:
+    lines = f.readlines()
+
+if any("hasattr(self, '_use_replicated_tensor_module')" in l for l in lines):
+    print("✓ distributed.py 已修复过，跳过")
+    raise SystemExit(0)
+
+patched = False
+for i, line in enumerate(lines):
+    if "module_to_run" in line and "_replicated_tensor_module" in line and line.rstrip().endswith("\\\\"):
+        # 兼容下一行是 self._use_replicated_tensor_module 的写法
+        if i + 1 < len(lines) and "self._use_replicated_tensor_module" in lines[i + 1]:
+            lines[i] = "        module_to_run = self._replicated_tensor_module if \\\\\\n"
+            lines[i + 1] = ("            (hasattr(self, '_use_replicated_tensor_module') "
+                            "and self._use_replicated_tensor_module) else self.module\\n")
+            patched = True
+            break
+    if "module_to_run" in line and "self._use_replicated_tensor_module" in line:
+        lines[i] = "        module_to_run = self._replicated_tensor_module if \\\\\\n"
+        lines[i + 1] = ("            (hasattr(self, '_use_replicated_tensor_module') "
+                        "and self._use_replicated_tensor_module) else self.module\\n")
+        patched = True
+        break
+
+if patched:
+    with open(dist_file, "w") as f:
+        f.writelines(lines)
+    print("✓ distributed.py 修复完成")
+else:
+    print("⚠ distributed.py 未找到目标行，跳过")
+PY
+
+echo "========================================"
+echo "修复完成"
+echo "如需回滚："
+echo "  cp ${FUNC_FILE}.bak ${FUNC_FILE}"
+echo "  cp ${DIST_FILE}.bak ${DIST_FILE}"
+echo "========================================"

experimental/build_env/fix_mmcv_temp.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""临时修复脚本：修复 mmcv distributed.py 的兼容性问题"""
+
+file_path = "/home/tiger/.local/lib/python3.11/site-packages/mmcv/parallel/distributed.py"
+
+# 读取文件
+with open(file_path, 'r') as f:
+    lines = f.readlines()
+
+# 修改第160行（索引159）
+if len(lines) > 159 and 'self._use_replicated_tensor_module else self.module' in lines[159]:
+    lines[159] = "            (hasattr(self, '_use_replicated_tensor_module') and self._use_replicated_tensor_module) else self.module\n"
+    
+    # 写回文件
+    with open(file_path, 'w') as f:
+        f.writelines(lines)
+    
+    print("✅ 修复完成！")
+    print("\n修改后的代码（第159-162行）：")
+    print(''.join(lines[158:162]))
+else:
+    print("❌ 第160行内容不符，当前内容：")
+    if len(lines) > 159:
+        print(lines[159])
+    else:
+        print("文件行数不足")

experimental/build_env/mmcv_pytorch26_compatibility_fix.md

@@ -0,0 +1,145 @@
+# mmcv-full 1.7.2 与 PyTorch 2.6.0 兼容性修复
+
+## 问题描述
+
+在 PyTorch 2.6.0 + CUDA 12.4 环境下使用 mmcv-full 1.7.2 进行多卡分布式推理时，会遇到以下错误：
+
+```
+AttributeError: 'MMDistributedDataParallel' object has no attribute '_use_replicated_tensor_module'
+```
+
+**错误位置**：`/home/tiger/.local/lib/python3.11/site-packages/mmcv/parallel/distributed.py:160`
+
+**根本原因**：PyTorch 2.6.0 引入了新的 `_use_replicated_tensor_module` 属性，但 mmcv-full 1.7.2 直接访问该属性而没有检查其是否存在，导致在旧版本 PyTorch 或特定情况下报错。
+
+## 修复方案
+
+### 方法1：修改 mmcv 源码（推荐）
+
+修改 `mmcv/parallel/distributed.py` 文件的第160行，添加 `hasattr` 检查：
+
+**修复步骤**：
+
+1. **备份原文件**：
+```bash
+cp /home/tiger/.local/lib/python3.11/site-packages/mmcv/parallel/distributed.py \
+   /home/tiger/.local/lib/python3.11/site-packages/mmcv/parallel/distributed.py.bak
+```
+
+2. **执行修复脚本**：
+```bash
+python3 << 'EOF'
+file_path = "/home/tiger/.local/lib/python3.11/site-packages/mmcv/parallel/distributed.py"
+
+# 从备份恢复（如果需要）
+import shutil
+import os
+if os.path.exists(file_path + ".bak"):
+    shutil.copy(file_path + ".bak", file_path)
+
+# 读取文件
+with open(file_path, 'r') as f:
+    lines = f.readlines()
+
+# 修改第159-160行（索引从0开始是158-159）
+# 原始代码：
+#   module_to_run = self._replicated_tensor_module if \
+#       self._use_replicated_tensor_module else self.module
+#
+# 修改为：
+lines[159] = "        module_to_run = self._replicated_tensor_module if \\\n"
+lines[160] = "            (hasattr(self, '_use_replicated_tensor_module') and self._use_replicated_tensor_module) else self.module\n"
+
+# 写回文件
+with open(file_path, 'w') as f:
+    f.writelines(lines)
+
+print("✅ 修复完成！")
+print("\n修改后的代码（第159-161行）：")
+print(''.join(lines[158:162]))
+EOF
+```
+
+3. **验证修复**：
+```bash
+sed -n '159,161p' /home/tiger/.local/lib/python3.11/site-packages/mmcv/parallel/distributed.py
+```
+
+期望输出：
+```python
+        module_to_run = self._replicated_tensor_module if \
+            (hasattr(self, '_use_replicated_tensor_module') and self._use_replicated_tensor_module) else self.module
+
+```
+
+### 方法2：降级 PyTorch（不推荐）
+
+降级到 PyTorch 2.1.x 或 2.2.x，但会失去新版本的功能和性能优化。
+
+## 补充：PyTorch 2.6 + mmcv 1.7.2 的 Scatter 兼容问题
+
+### 问题描述
+
+在多卡训练/推理时，可能出现以下错误（来自 `mmcv/parallel/_functions.py`）：
+
+```
+AttributeError: 'int' object has no attribute 'type'
+```
+
+该问题的根因是 `_get_stream` 在 PyTorch 2.6 中期望 `torch.device`，
+但 mmcv 传入的是 int 类型的 GPU id。
+
+### 一键修复脚本（推荐）
+
+运行仓库内脚本：
+
+```bash
+bash /mnt/bn/strategy-mllm-train/user/wangjunjie/code/xiaomoguhzz/DeCLIP_private/build_env/fix_mmcv_pytorch26_v2.sh
+```
+
+该脚本会：
+
+- 自动定位 `mmcv/parallel/_functions.py`
+- 备份原文件（`.bak`）
+- 将 `streams = [_get_stream(device) for device in target_gpus]`
+  修改为兼容 PyTorch 2.6 的 `torch.device` 写法
+- 可选修复 `distributed.py` 中 `_use_replicated_tensor_module` 的兼容问题
+
+### 手工修复要点（仅供参考）
+
+目标代码片段应类似：
+
+```python
+streams = [
+    _get_stream(torch.device('cuda', d) if isinstance(d, int) else d)
+    for d in target_gpus
+]
+```
+
+## 修复验证
+
+修复后，运行多卡推理脚本应该正常工作：
+
+```bash
+cd /mnt/bn/strategy-mllm-train/user/wangjunjie/code/xiaomoguhzz/DeCLIP_private/failure_case_analysis/scripts
+bash run_inference.sh 0 8
+```
+
+## 相关问题记录
+
+- **日期**：2026-01-24
+- **环境**：PyTorch 2.6.0+cu124, mmcv-full 1.7.2, CUDA 12.4
+- **影响范围**：所有使用 `MMDistributedDataParallel` 的多卡分布式训练/推理代码
+- **修复状态**：已修复并验证
+
+## 参考资料
+
+- mmcv GitHub Issue: https://github.com/open-mmlab/mmcv/issues
+- PyTorch 2.6.0 Release Notes: https://github.com/pytorch/pytorch/releases/tag/v2.6.0
+- mmcv 兼容性说明: https://github.com/open-mmlab/mmcv/blob/master/docs/en/compatibility.md
+
+## 注意事项
+
+1. 该修复是临时方案，建议长期使用 mmcv 2.x 版本以获得更好的兼容性
+2. 如果重新安装 mmcv-full，需要重新应用此修复
+3. 修复后的代码保持向后兼容，不影响旧版本 PyTorch 的使用

experimental/build_env/proxyclip/README.md

@@ -0,0 +1,190 @@
+# ProxyCLIP Environment Setup
+
+This directory contains scripts to set up the ProxyCLIP semantic segmentation environment.
+
+## Quick Start
+
+```bash
+# 1. Setup environment (one-time)
+bash setup_env.sh
+
+# 2. Activate environment
+source activate.sh
+
+# 3. Download datasets (optional, can select specific ones)
+bash download_datasets.sh
+
+# 4. Run evaluation
+cd ../../ProxyCLIP
+python eval.py --config ./configs/cfg_voc20.py
+```
+
+## Environment Details
+
+The environment includes:
+- Python 3.10
+- PyTorch 2.6.0 + CUDA 12.4
+- mmcv 2.1.0
+- mmengine 0.10.4
+- mmdet 3.3.0
+- mmsegmentation 1.2.2
+
+## Scripts
+
+| Script | Description |
+|--------|-------------|
+| `setup_env.sh` | Creates uv virtual environment and installs all dependencies |
+| `activate.sh` | Activates the virtual environment |
+| `download_datasets.sh` | Downloads semantic segmentation datasets |
+| `setup_data_paths.py` | Helps configure data paths in config files |
+| `requirements.txt` | Python dependencies |
+
+## Datasets
+
+The following 8 datasets are supported:
+
+| Dataset | Size | Notes |
+|---------|------|-------|
+| Pascal VOC 2012 | ~2GB | Automatic download |
+| Pascal Context | ~2GB | Requires conversion |
+| ADE20K | ~1GB | Automatic download |
+| Cityscapes | ~12GB | Manual registration required |
+| COCO-Stuff 164K | ~20GB | Automatic download |
+| COCO-Object | - | Converted from COCO-Stuff |
+
+### Cityscapes Download
+
+Cityscapes requires manual registration:
+1. Register at: https://www.cityscapes-dataset.com/register/
+2. Download: `leftImg8bit_trainvaltest.zip` and `gtFine_trainvaltest.zip`
+3. Extract to: `data/cityscapes/`
+
+## Data Directory Structure
+
+After downloading all datasets, the structure should be:
+
+```
+data/
+├── VOCdevkit/
+│   ├── VOC2012/              # Pascal VOC 2012
+│   │   ├── JPEGImages/
+│   │   ├── SegmentationClass/
+│   │   └── ImageSets/Segmentation/
+│   └── VOC2010/              # Pascal Context
+│       ├── JPEGImages/
+│       ├── SegmentationClassContext/
+│       └── ImageSets/SegmentationContext/
+├── ADEChallengeData2016/     # ADE20K
+│   ├── images/
+│   │   └── validation/
+│   └── annotations/
+│       └── validation/
+├── cityscapes/               # Cityscapes
+│   ├── leftImg8bit/
+│   │   └── val/
+│   └── gtFine/
+│       └── val/
+├── coco_stuff164k/           # COCO-Stuff 164K
+│   ├── images/
+│   │   └── val2017/
+│   └── annotations/
+│       └── val2017/
+└── coco_object/              # COCO-Object
+    ├── images/
+    │   └── val2017/
+    └── annotations/
+        └── val2017/
+```
+
+## Running Experiments
+
+### Single Dataset Evaluation
+
+```bash
+source activate.sh
+cd ../../ProxyCLIP
+
+# Evaluate on Pascal VOC 20
+python eval.py --config ./configs/cfg_voc20.py --work-dir ./work_logs/
+
+# Evaluate on ADE20K
+python eval.py --config ./configs/cfg_ade20k.py --work-dir ./work_logs/
+```
+
+### Multi-GPU Evaluation
+
+```bash
+# Using 4 GPUs (default)
+bash dist_test.sh ./configs/cfg_voc20.py
+
+# Using 8 GPUs
+GPUS=8 bash dist_test.sh ./configs/cfg_voc20.py
+```
+
+### Evaluate All Datasets
+
+```bash
+python eval_all.py
+```
+
+This generates `results.xlsx` with metrics for all 8 datasets.
+
+## Server Data Paths (已配置)
+
+数据集已下载到服务器 `/opt/tiger/xiaomoguhzz/dataset`，配置文件已更新。
+
+### 数据集路径映射
+
+| 数据集 | 服务器路径 |
+|--------|-----------|
+| ADE20K | `/opt/tiger/xiaomoguhzz/dataset/ADEChallengeData2016` |
+| Cityscapes | `/opt/tiger/xiaomoguhzz/dataset/cityscapes` |
+| COCO-Object | `/opt/tiger/xiaomoguhzz/dataset/coco_obj` |
+| COCO-Stuff | `/opt/tiger/xiaomoguhzz/standard_coco` |
+| Pascal VOC | `/opt/tiger/xiaomoguhzz/dataset/VOCdevkit/VOC2012` |
+| Pascal Context | `/opt/tiger/xiaomoguhzz/dataset/VOCdevkit/VOC2010` |
+
+### 模型权重路径
+
+| 模型 | 路径 | 推理模式 |
+|------|------|----------|
+| CLIP | `/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt` | vanilla |
+| DeCLIP | `/mnt/bn/.../logs/DeCLIP_EVA-B_DINOv2-B_560/checkpoints/epoch_6.pt` | csa |
+
+### 快速测试
+
+```bash
+# 进入 ProxyCLIP_TPAMI 目录
+cd ../../ProxyCLIP_TPAMI
+
+# DeCLIP 评估
+python eval.py --config ./configs/eva_declip/cfg_voc21.py
+
+# CLIP baseline 评估
+python eval.py --config ./configs/eva_clip/cfg_voc21.py
+```
+
+---
+
+## Troubleshooting
+
+### CUDA Out of Memory
+Reduce the sliding window crop size in the config:
+```python
+model = dict(
+    slide_stride=112,
+    slide_crop=224,  # Reduce from 336 to 224
+)
+```
+
+### Module Not Found
+Make sure the environment is activated:
+```bash
+source activate.sh
+```
+
+### Data Path Errors
+Update the data paths in config files to match your data location:
+```bash
+python setup_data_paths.py --data-root /path/to/your/data
+```

experimental/build_env/proxyclip/activate.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Convenience script to activate the ProxyCLIP environment
+# Usage: source activate.sh
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BUILD_ENV_DIR="$(dirname "$SCRIPT_DIR")"
+PROJECT_ROOT="$(dirname "$BUILD_ENV_DIR")"
+VENV_DIR="$PROJECT_ROOT/.venv_proxyclip"
+
+if [ ! -d "$VENV_DIR" ]; then
+    echo "[ERROR] Virtual environment not found at $VENV_DIR"
+    echo "Please run setup_env.sh first:"
+    echo "  bash $SCRIPT_DIR/setup_env.sh"
+    return 1 2>/dev/null || exit 1
+fi
+
+source "$VENV_DIR/bin/activate"
+echo "ProxyCLIP environment activated!"
+echo "Python: $(which python)"
+echo "PyTorch: $(python -c 'import torch; print(torch.__version__)')"

experimental/build_env/proxyclip/download_datasets.sh

@@ -0,0 +1,312 @@
+#!/bin/bash
+# Dataset Download Script for ProxyCLIP
+# Downloads and prepares semantic segmentation datasets
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BUILD_ENV_DIR="$(dirname "$SCRIPT_DIR")"
+PROJECT_ROOT="$(dirname "$BUILD_ENV_DIR")"
+
+# Default data directory - can be customized
+DATA_ROOT="${DATA_ROOT:-$PROJECT_ROOT/data}"
+
+echo "=============================================="
+echo "ProxyCLIP Dataset Download Script"
+echo "=============================================="
+echo "Data will be downloaded to: $DATA_ROOT"
+echo ""
+
+mkdir -p "$DATA_ROOT"
+cd "$DATA_ROOT"
+
+# Function to download with resume support
+download_file() {
+    local url=$1
+    local filename=$2
+    if [ -f "$filename" ]; then
+        echo "  $filename already exists, skipping download."
+    else
+        echo "  Downloading $filename..."
+        wget -c "$url" -O "$filename"
+    fi
+}
+
+# ============================================
+# 1. Pascal VOC 2012
+# ============================================
+download_voc() {
+    echo ""
+    echo "[1/6] Pascal VOC 2012"
+    echo "----------------------------------------"
+
+    VOC_DIR="$DATA_ROOT/VOCdevkit/VOC2012"
+    if [ -d "$VOC_DIR" ]; then
+        echo "  Pascal VOC 2012 already exists at $VOC_DIR"
+        return
+    fi
+
+    mkdir -p "$DATA_ROOT/VOCdevkit"
+    cd "$DATA_ROOT/VOCdevkit"
+
+    # Download VOC 2012 trainval
+    download_file "http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar" "VOCtrainval_11-May-2012.tar"
+
+    echo "  Extracting..."
+    tar -xf VOCtrainval_11-May-2012.tar
+
+    echo "  Pascal VOC 2012 ready at: $VOC_DIR"
+}
+
+# ============================================
+# 2. Pascal Context
+# ============================================
+download_pascal_context() {
+    echo ""
+    echo "[2/6] Pascal Context"
+    echo "----------------------------------------"
+
+    CONTEXT_DIR="$DATA_ROOT/VOCdevkit/VOC2010"
+    if [ -d "$CONTEXT_DIR/SegmentationClassContext" ]; then
+        echo "  Pascal Context already exists at $CONTEXT_DIR"
+        return
+    fi
+
+    # Pascal Context uses VOC2010 images
+    mkdir -p "$DATA_ROOT/VOCdevkit"
+    cd "$DATA_ROOT/VOCdevkit"
+
+    # Download VOC 2010
+    if [ ! -d "VOC2010" ]; then
+        download_file "http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar" "VOCtrainval_03-May-2010.tar"
+        echo "  Extracting VOC 2010..."
+        tar -xf VOCtrainval_03-May-2010.tar
+    fi
+
+    # Download Pascal Context annotations
+    cd "$DATA_ROOT"
+    if [ ! -f "trainval_merged.json" ]; then
+        echo "  Downloading Pascal Context annotations..."
+        download_file "https://cs.stanford.edu/~roozbeh/pascal-context/trainval_merged.json" "trainval_merged.json"
+    fi
+
+    echo ""
+    echo "  [NOTE] Pascal Context requires additional processing."
+    echo "  Please run the conversion script after download:"
+    echo "    python $SCRIPT_DIR/convert_pascal_context.py"
+    echo ""
+}
+
+# ============================================
+# 3. ADE20K
+# ============================================
+download_ade20k() {
+    echo ""
+    echo "[3/6] ADE20K"
+    echo "----------------------------------------"
+
+    ADE_DIR="$DATA_ROOT/ADEChallengeData2016"
+    if [ -d "$ADE_DIR" ]; then
+        echo "  ADE20K already exists at $ADE_DIR"
+        return
+    fi
+
+    cd "$DATA_ROOT"
+
+    # Download ADE20K
+    download_file "http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip" "ADEChallengeData2016.zip"
+
+    echo "  Extracting..."
+    unzip -q ADEChallengeData2016.zip
+
+    echo "  ADE20K ready at: $ADE_DIR"
+}
+
+# ============================================
+# 4. Cityscapes (Manual download required)
+# ============================================
+download_cityscapes() {
+    echo ""
+    echo "[4/6] Cityscapes"
+    echo "----------------------------------------"
+
+    CITY_DIR="$DATA_ROOT/cityscapes"
+    if [ -d "$CITY_DIR/leftImg8bit" ] && [ -d "$CITY_DIR/gtFine" ]; then
+        echo "  Cityscapes already exists at $CITY_DIR"
+        return
+    fi
+
+    echo "  [MANUAL DOWNLOAD REQUIRED]"
+    echo ""
+    echo "  Cityscapes requires registration. Please:"
+    echo "  1. Register at: https://www.cityscapes-dataset.com/register/"
+    echo "  2. Download the following files:"
+    echo "     - leftImg8bit_trainvaltest.zip (11GB)"
+    echo "     - gtFine_trainvaltest.zip (241MB)"
+    echo "  3. Extract to: $CITY_DIR"
+    echo ""
+    echo "  Expected structure:"
+    echo "    $CITY_DIR/"
+    echo "    ├── leftImg8bit/"
+    echo "    │   ├── train/"
+    echo "    │   ├── val/"
+    echo "    │   └── test/"
+    echo "    └── gtFine/"
+    echo "        ├── train/"
+    echo "        ├── val/"
+    echo "        └── test/"
+    echo ""
+
+    mkdir -p "$CITY_DIR"
+}
+
+# ============================================
+# 5. COCO-Stuff 164K
+# ============================================
+download_coco_stuff() {
+    echo ""
+    echo "[5/6] COCO-Stuff 164K"
+    echo "----------------------------------------"
+
+    COCO_DIR="$DATA_ROOT/coco_stuff164k"
+    if [ -d "$COCO_DIR/images" ] && [ -d "$COCO_DIR/annotations" ]; then
+        echo "  COCO-Stuff 164K already exists at $COCO_DIR"
+        return
+    fi
+
+    mkdir -p "$COCO_DIR"
+    cd "$COCO_DIR"
+
+    # Download COCO images (train2017 and val2017)
+    echo "  Downloading COCO images..."
+    mkdir -p images
+    cd images
+
+    if [ ! -d "train2017" ]; then
+        download_file "http://images.cocodataset.org/zips/train2017.zip" "train2017.zip"
+        echo "  Extracting train2017..."
+        unzip -q train2017.zip
+    fi
+
+    if [ ! -d "val2017" ]; then
+        download_file "http://images.cocodataset.org/zips/val2017.zip" "val2017.zip"
+        echo "  Extracting val2017..."
+        unzip -q val2017.zip
+    fi
+
+    cd "$COCO_DIR"
+
+    # Download COCO-Stuff annotations
+    echo "  Downloading COCO-Stuff annotations..."
+    mkdir -p annotations
+    cd annotations
+
+    if [ ! -d "train2017" ]; then
+        download_file "http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip" "stuffthingmaps_trainval2017.zip"
+        echo "  Extracting annotations..."
+        unzip -q stuffthingmaps_trainval2017.zip
+    fi
+
+    echo "  COCO-Stuff 164K ready at: $COCO_DIR"
+}
+
+# ============================================
+# 6. COCO-Object (Converted from COCO-Stuff)
+# ============================================
+prepare_coco_object() {
+    echo ""
+    echo "[6/6] COCO-Object"
+    echo "----------------------------------------"
+
+    COCO_OBJ_DIR="$DATA_ROOT/coco_object"
+    COCO_STUFF_DIR="$DATA_ROOT/coco_stuff164k"
+
+    if [ -d "$COCO_OBJ_DIR" ]; then
+        echo "  COCO-Object already exists at $COCO_OBJ_DIR"
+        return
+    fi
+
+    if [ ! -d "$COCO_STUFF_DIR" ]; then
+        echo "  [WARNING] COCO-Stuff 164K not found. Please download it first."
+        return
+    fi
+
+    echo "  Converting COCO-Stuff to COCO-Object..."
+    echo "  Please run the conversion script:"
+    echo "    python $PROJECT_ROOT/ProxyCLIP/datasets/cvt_coco_object.py $COCO_STUFF_DIR -o $COCO_OBJ_DIR"
+    echo ""
+}
+
+# ============================================
+# Main execution
+# ============================================
+echo "Select datasets to download (comma-separated, or 'all'):"
+echo "  1. voc        - Pascal VOC 2012 (~2GB)"
+echo "  2. context    - Pascal Context (~2GB + processing)"
+echo "  3. ade20k     - ADE20K (~1GB)"
+echo "  4. cityscapes - Cityscapes (manual, ~12GB)"
+echo "  5. cocostuff  - COCO-Stuff 164K (~20GB)"
+echo "  6. cocoobj    - COCO-Object (converted from COCO-Stuff)"
+echo ""
+
+# Check for command line argument
+if [ -n "$1" ]; then
+    SELECTION="$1"
+else
+    read -p "Enter selection (default: all): " SELECTION
+    SELECTION="${SELECTION:-all}"
+fi
+
+download_selected() {
+    case "$1" in
+        voc|1)
+            download_voc
+            ;;
+        context|2)
+            download_pascal_context
+            ;;
+        ade20k|3)
+            download_ade20k
+            ;;
+        cityscapes|4)
+            download_cityscapes
+            ;;
+        cocostuff|5)
+            download_coco_stuff
+            ;;
+        cocoobj|6)
+            prepare_coco_object
+            ;;
+        all)
+            download_voc
+            download_pascal_context
+            download_ade20k
+            download_cityscapes
+            download_coco_stuff
+            prepare_coco_object
+            ;;
+        *)
+            echo "Unknown dataset: $1"
+            ;;
+    esac
+}
+
+# Parse selection
+IFS=',' read -ra DATASETS <<< "$SELECTION"
+for dataset in "${DATASETS[@]}"; do
+    dataset=$(echo "$dataset" | tr -d ' ')
+    download_selected "$dataset"
+done
+
+echo ""
+echo "=============================================="
+echo "Download complete!"
+echo "=============================================="
+echo ""
+echo "Data location: $DATA_ROOT"
+echo ""
+echo "Next steps:"
+echo "  1. Update data paths in ProxyCLIP/configs/*.py"
+echo "  2. For Cityscapes, complete manual download"
+echo "  3. For Pascal Context and COCO-Object, run conversion scripts"
+echo ""

experimental/build_env/proxyclip/requirements.txt

@@ -0,0 +1,32 @@
+# PyTorch with CUDA 12.4
+--extra-index-url https://download.pytorch.org/whl/cu124
+torch==2.6.0+cu124
+torchvision==0.21.0+cu124
+torchaudio==2.6.0+cu124
+
+# OpenMMLab ecosystem
+mmcv==2.1.0
+mmengine==0.10.4
+mmdet==3.3.0
+
+# ProxyCLIP dependencies
+einops>=0.3.0
+ftfy>=6.2.0
+huggingface_hub>=0.23.0
+matplotlib>=3.7.2
+nltk>=3.8.1
+numpy<2.0.0
+opencv-python>=4.6.0
+opencv-python-headless>=4.8.0
+openpyxl>=3.1.2
+Pillow>=10.4.0
+pycocotools>=2.0.7
+regex>=2023.8.8
+safetensors>=0.4.3
+scipy>=1.14.0
+scikit-image
+timm>=0.4.12
+tqdm>=4.65.2
+transformers>=4.37.2
+prettytable
+packaging

experimental/build_env/proxyclip/setup_data_paths.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Script to update data paths in ProxyCLIP config files.
+Run this after downloading datasets to configure the correct paths.
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+
+# Default paths
+SCRIPT_DIR = Path(__file__).parent
+BUILD_ENV_DIR = SCRIPT_DIR.parent
+PROJECT_ROOT = BUILD_ENV_DIR.parent
+PROXYCLIP_DIR = PROJECT_ROOT / "ProxyCLIP_TPAMI"
+CONFIGS_DIR = PROXYCLIP_DIR / "configs"
+
+# Server default data path
+SERVER_DATA_ROOT = "/opt/tiger/xiaomoguhzz/dataset"
+
+
+def update_config_paths(data_root: str, dry_run: bool = False):
+    """Update data paths in ProxyCLIP config files."""
+
+    data_root = Path(data_root).resolve()
+
+    # Dataset path mappings
+    dataset_paths = {
+        "cfg_voc20.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "VOCdevkit/VOC2012/JPEGImages"),
+                "seg_map_path": str(data_root / "VOCdevkit/VOC2012/SegmentationClass"),
+            },
+            "ann_file": str(data_root / "VOCdevkit/VOC2012/ImageSets/Segmentation/val.txt"),
+        },
+        "cfg_voc21.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "VOCdevkit/VOC2012/JPEGImages"),
+                "seg_map_path": str(data_root / "VOCdevkit/VOC2012/SegmentationClass"),
+            },
+            "ann_file": str(data_root / "VOCdevkit/VOC2012/ImageSets/Segmentation/val.txt"),
+        },
+        "cfg_context59.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "VOCdevkit/VOC2010/JPEGImages"),
+                "seg_map_path": str(data_root / "VOCdevkit/VOC2010/SegmentationClassContext"),
+            },
+            "ann_file": str(data_root / "VOCdevkit/VOC2010/ImageSets/SegmentationContext/val.txt"),
+        },
+        "cfg_context60.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "VOCdevkit/VOC2010/JPEGImages"),
+                "seg_map_path": str(data_root / "VOCdevkit/VOC2010/SegmentationClassContext"),
+            },
+            "ann_file": str(data_root / "VOCdevkit/VOC2010/ImageSets/SegmentationContext/val.txt"),
+        },
+        "cfg_ade20k.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "ADEChallengeData2016/images/validation"),
+                "seg_map_path": str(data_root / "ADEChallengeData2016/annotations/validation"),
+            },
+        },
+        "cfg_city_scapes.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "cityscapes/leftImg8bit/val"),
+                "seg_map_path": str(data_root / "cityscapes/gtFine/val"),
+            },
+        },
+        "cfg_coco_stuff164k.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "coco_stuff164k/images/val2017"),
+                "seg_map_path": str(data_root / "coco_stuff164k/annotations/val2017"),
+            },
+        },
+        "cfg_coco_object.py": {
+            "data_prefix": {
+                "img_path": str(data_root / "coco_object/images/val2017"),
+                "seg_map_path": str(data_root / "coco_object/annotations/val2017"),
+            },
+        },
+    }
+
+    print("=" * 50)
+    print("Updating ProxyCLIP config files")
+    print("=" * 50)
+    print(f"Data root: {data_root}")
+    print(f"Config dir: {CONFIGS_DIR}")
+    print("")
+
+    if not CONFIGS_DIR.exists():
+        print(f"[ERROR] Config directory not found: {CONFIGS_DIR}")
+        return False
+
+    for config_name, paths in dataset_paths.items():
+        config_path = CONFIGS_DIR / config_name
+        if not config_path.exists():
+            print(f"[SKIP] {config_name} - file not found")
+            continue
+
+        print(f"[UPDATE] {config_name}")
+
+        # Read config file
+        with open(config_path, 'r') as f:
+            content = f.read()
+
+        # For now, just print what would be updated
+        if "data_prefix" in paths:
+            for key, value in paths["data_prefix"].items():
+                print(f"         {key}: {value}")
+        if "ann_file" in paths:
+            print(f"         ann_file: {paths['ann_file']}")
+
+    print("")
+    print("=" * 50)
+    print("")
+    print("To apply these changes, you need to manually update the config files.")
+    print("Each config file has a 'test_dataloader' section with 'data_prefix' settings.")
+    print("")
+    print("Example structure:")
+    print("  test_dataloader = dict(")
+    print("      dataset=dict(")
+    print("          data_prefix=dict(")
+    print(f"              img_path='{data_root}/VOCdevkit/VOC2012/JPEGImages',")
+    print(f"              seg_map_path='{data_root}/VOCdevkit/VOC2012/SegmentationClass',")
+    print("          ),")
+    print("      )")
+    print("  )")
+    print("")
+
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Update data paths in ProxyCLIP configs")
+    parser.add_argument(
+        "--data-root",
+        type=str,
+        default=SERVER_DATA_ROOT,
+        help="Root directory containing all datasets (default: server path)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be changed without modifying files",
+    )
+
+    args = parser.parse_args()
+
+    success = update_config_paths(args.data_root, args.dry_run)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

experimental/build_env/proxyclip/setup_env.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# ProxyCLIP Environment Setup Script
+# Creates an isolated uv virtual environment with all dependencies
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BUILD_ENV_DIR="$(dirname "$SCRIPT_DIR")"
+PROJECT_ROOT="$(dirname "$BUILD_ENV_DIR")"
+VENV_DIR="/opt/tiger/xiaomoguhzz/envs/proxyclip_venv"
+MMSEG_DIR="$PROJECT_ROOT/mmsegmentation"
+
+echo "=============================================="
+echo "ProxyCLIP Environment Setup"
+echo "=============================================="
+echo "Project root: $PROJECT_ROOT"
+echo "Virtual env:  $VENV_DIR"
+echo ""
+
+# Check if uv is installed
+if ! command -v uv &> /dev/null; then
+    echo "[ERROR] uv is not installed. Please install uv first:"
+    echo "  curl -LsSf https://astral.sh/uv/install.sh | sh"
+    exit 1
+fi
+
+echo "[1/5] Creating virtual environment with Python 3.10..."
+if [ -d "$VENV_DIR" ]; then
+    echo "  Virtual environment already exists, removing..."
+    rm -rf "$VENV_DIR"
+fi
+uv venv "$VENV_DIR" --python 3.10
+
+echo ""
+echo "[2/5] Installing base dependencies from requirements.txt..."
+uv pip install -r "$SCRIPT_DIR/requirements.txt" --python "$VENV_DIR/bin/python"
+
+echo ""
+echo "[3/5] Installing mmsegmentation from PyPI..."
+    uv pip install mmsegmentation==1.2.2 --python "$VENV_DIR/bin/python"
+
+echo ""
+echo "[4/5] Installing open_clip from ProxyCLIP..."
+PROXYCLIP_DIR="$PROJECT_ROOT/ProxyCLIP"
+if [ -d "$PROXYCLIP_DIR/open_clip" ]; then
+    echo "  open_clip package is included in ProxyCLIP, no additional installation needed."
+else
+    echo "  Installing open_clip_torch..."
+    uv pip install open_clip_torch --python "$VENV_DIR/bin/python"
+fi
+
+echo ""
+echo "[5/5] Verifying installation..."
+"$VENV_DIR/bin/python" -c "
+import torch
+import mmcv
+import mmengine
+import mmseg
+
+print('PyTorch version:', torch.__version__)
+print('CUDA available:', torch.cuda.is_available())
+if torch.cuda.is_available():
+    print('CUDA version:', torch.version.cuda)
+    print('GPU count:', torch.cuda.device_count())
+print('mmcv version:', mmcv.__version__)
+print('mmengine version:', mmengine.__version__)
+print('mmseg version:', mmseg.__version__)
+"
+
+echo ""
+echo "=============================================="
+echo "Setup completed successfully!"
+echo "=============================================="
+echo ""
+echo "To activate the environment, run:"
+echo "  source $VENV_DIR/bin/activate"
+echo ""
+echo "Or use the convenience script:"
+echo "  source $SCRIPT_DIR/activate.sh"
+echo ""
+echo "Next steps:"
+echo "  1. Download datasets: bash $SCRIPT_DIR/download_datasets.sh"
+echo "  2. Configure data paths in ProxyCLIP/configs/"
+echo "  3. Run evaluation: cd $PROXYCLIP_DIR && python eval.py --config ./configs/cfg_voc20.py"
+echo ""

scripts/ablation_ijepa/debug_ijepa_gsc_eva_vitL14_336_coco.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# JEPA-GSC 消融实验：EVA-CLIP-L/14-336 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Debug_JEPA-GSC_EVA-L_DINOv2-B_csa_336
+vfm_type=dinov2-B
+dataset_type=ablation_ijepa
+version=ablation_ijepa
+mode=csa_vfm_distill
+
+# 单卡调试
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=2 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy  \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version} \
+    --train-ratio 0.01

scripts/ablation_ijepa/debug_ijepa_gsc_eva_vitb16_coco.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# JEPA-GSC 消融实验：EVA-CLIP-B/16 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=Debug_JEPA-GSC_EVA-B_DINOv2-B_csa_560
+vfm_type=dinov2-B
+dataset_type=ablation_ijepa
+version=ablation_ijepa
+mode=csa_vfm_distill
+
+# 单卡调试
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=2 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version} \
+    --train-ratio 0.01

scripts/ablation_ijepa/dist_ijepa_gsc_eva_vitL14_336_coco.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+# JEPA-GSC 消融实验：EVA-CLIP-L/14-336 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Ablation_JEPA-GSC_EVA-L_DINOv2-B_csa_336
+vfm_type=dinov2-B
+dataset_type=ablation_ijepa
+version=ablation_ijepa
+mode=csa_vfm_distill
+
+# Parse arguments for nohup
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12349 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy  \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version}" \
+    --resume /mnt/bn/strategy-mllm-train/user/wangjunjie/code/xiaomoguhzz/DeCLIP_private/logs/Ablation_JEPA-GSC_EVA-L_DINOv2-B_csa_336/checkpoints/epoch_5.pt
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/ablation_ijepa/dist_ijepa_gsc_eva_vitb16_coco.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# JEPA-GSC 消融实验：EVA-CLIP-B/16 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=Ablation_JEPA-GSC_EVA-B_DINOv2-B_csa_560
+vfm_type=dinov2-B
+dataset_type=ablation_ijepa
+version=ablation_ijepa
+mode=csa_vfm_distill
+
+# Parse arguments for nohup
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+# 多卡训练：总 batch_size=16
+# 请根据实际 GPU 数量调整 --nproc_per_node 和 --batch-size
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12340 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/ablation_ijepa/resume_ijepa_gsc_eva_vitL14_336.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# Resume Ablation_JEPA-GSC_EVA-L_DINOv2-B_csa_336 实验
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Ablation_JEPA-GSC_EVA-L_DINOv2-B_csa_336
+resume_ckpt=logs/${exp_name}/checkpoints/epoch_5.pt
+
+cd /mnt/bn/strategy-mllm-train/user/wangjunjie/code/xiaomoguhzz/DeCLIP_private
+
+echo "Resuming: $exp_name"
+echo "Checkpoint: $resume_ckpt"
+
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12342 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ablation_ijepa \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode csa_vfm_distill \
+    --use_vfm dinov2-B \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ablation_ijepa \
+    --resume ${resume_ckpt}

scripts/ablation_sam/debug_sam_gsc_eva_vitL14_336_coco.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# SAM-GSC 消融实验：EVA-CLIP-L/14-336 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Debug_SAM-GSC_EVA-L_DINOv2-B_csa_336
+vfm_type=dinov2-B
+dataset_type=ablation_sam
+version=ablation_sam
+mode=csa_vfm_distill
+
+# 单卡调试
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=2 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version} \
+    --train-ratio 0.01

scripts/ablation_sam/debug_sam_gsc_eva_vitb16_coco.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# SAM-GSC 消融实验：EVA-CLIP-B/16 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=Debug_SAM-GSC_EVA-B_DINOv2-B_csa_560
+vfm_type=dinov2-B
+dataset_type=ablation_sam
+version=ablation_sam
+mode=csa_vfm_distill
+
+# 单卡调试
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=2 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version} \
+    --train-ratio 0.01

scripts/ablation_sam/dist_sam_gsc_eva_vitL14_336_coco.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# SAM-GSC 消融实验：EVA-CLIP-L/14-336 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Ablation_SAM-GSC_EVA-L_DINOv2-B_csa_560
+vfm_type=dinov2-B
+dataset_type=ablation_sam
+version=ablation_sam
+mode=csa_vfm_distill
+
+# Parse arguments for nohup
+USE_NOHUP=false
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+# 多卡训练：总 batch_size=16
+# EVA-CLIP-L 显存占用更大，可能需要减少每卡 batch_size
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12347 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy  \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/ablation_sam/dist_sam_gsc_eva_vitb16_coco.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+# SAM-GSC 消融实验：EVA-CLIP-B/16 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=Ablation_SAM-GSC_EVA-B_DINOv2-B_csa_560
+vfm_type=dinov2-B
+dataset_type=ablation_sam
+version=ablation_sam
+mode=csa_vfm_distill
+
+# Parse arguments for nohup
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+# 多卡训练：总 batch_size=16
+# 请根据实际 GPU 数量调整 --nproc_per_node 和 --batch-size
+# 例如：4卡 x 4 = 16, 2卡 x 8 = 16, 8卡 x 2 = 16
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12348 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --sd-refine-weight 0.3 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/declip+/DeCLIP+_eva_vitb16_coco.sh

@@ -0,0 +1,17 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=test
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=dift_proposals_distill # {proposals_distill,grid_distill,dift_grid_distill,dift_proposals_distill}
+version=declip+ # {declip,declip2,declip+}
+mode=csa_vfm_distill
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=0 torchrun --nproc_per_node 1 --master_port 29500 -m training.main --batch-size=2 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-B-16 --pretrained eva --warmup 1000 --zeroshot-frequency 6 --dataset-type ${dataset_type} \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 560 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode ${mode} --use_vfm ${vfm_type} --loss_context_weight 0.25 --loss_content_weight 1.0 --loss_region_weight 0.1 --skip-first-eval --repa_layer_idx -1 --sd-refine-weight 1.0 --cache-self-attn sd_self_attn_cache/sd_self_attn_coco.h5 --version ${version} --eval

scripts/declip+/dist_DeCLIP+_eva_vitL14_336_coco.sh

@@ -0,0 +1,17 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=EVAL_dinov2B_csa_490_plus_exp95_sd0.2_0.1_1.0_0.2
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=dift_grid_distill # {proposals_distill,grid_distill,dift_grid_distill}
+version=declip+ # {declip,declip2,declip+}
+mode=csa_vfm_distill
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 29500 -m training.main --batch-size=1 --lr=5e-6 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-L-14-336 --pretrained eva --warmup 1000  --zeroshot-frequency 1 --dataset-type ${dataset_type}  \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 24 \
+--name ${exp_name} --downsample-factor 14 --det-image-size 490 --val-segm-root  ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.95  --use_vfm ${vfm_type} --mode ${mode} --loss_context_weight 0.1 --loss_content_weight 1.0 --loss_region_weight 0.2 --skip-first-eval --version ${version} --grad-checkpointing --sd-refine-weight 0.2 --cache-self-attn sd_self_attn_cache/sd_self_attn_coco.h5

scripts/declip+/dist_DeCLIP+_eva_vitL14_336_lvis.sh

@@ -0,0 +1,17 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=EVAL_dinov2B_qq_896_plus_0.1_2.0_1.0_lvis
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=grid_distill # {proposals_distill,grid_distill,dift_grid_distill}
+mode=qq_vfm_distill
+
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 29500 -m training.main --batch-size=1 --lr=5e-6 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-L-14-336 --pretrained eva --warmup 1000  --zeroshot-frequency 1 --dataset-type ${dataset_type}  \
+--test-type coco_panoptic --train-data ${data_root}/annotations/lvis_v1_train.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy --train-image-root ${data_root} \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 24 \
+--name ${exp_name} --downsample-factor 14 --det-image-size 896 --val-segm-root  ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.95  --use_vfm ${vfm_type} --mode ${mode} --loss_context_weight 0.1 --loss_content_weight 2.0 --skip-first-eval --version declip2 --grad-checkpointing

scripts/declip+/dist_DeCLIP+_eva_vitb16_coco.sh

@@ -0,0 +1,17 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=EVA-B_DINOv2-B_csa_560_declip2_0.25_1.0_0.05
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=grid_distill # {proposals_distill,grid_distill,dift_grid_distill,dift_proposals_distill}
+version=declip2 # {declip,declip2,declip+}
+mode=csa_vfm_distill
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node 4 --master_port 29500 -m training.main --batch-size=4 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-B-16 --pretrained eva --warmup 1000 --zeroshot-frequency 6 --dataset-type ${dataset_type} \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 560 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode ${mode} --use_vfm ${vfm_type} --loss_context_weight 0.25 --loss_content_weight 1.0 --loss_region_weight 0.05 --skip-first-eval --repa_layer_idx -1 --sd-refine-weight 1.0 --cache-self-attn sd_self_attn_cache/sd_self_attn_coco.h5 --version ${version}

scripts/declip+/dist_DeCLIP+_eva_vitb16_coco_seg.sh

@@ -0,0 +1,17 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=EVA-B_DINOv2-B_csa_560_plus_sd1.0_0.9_1.0_0.3
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=dift_grid_distill # {proposals_distill,grid_distill,dift_grid_distill}
+version=declip+ # {declip,declip2,declip+}
+mode=csa_vfm_distill
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=4,5,6,7 torchrun --nproc_per_node 4 --master_port 29501 -m training.main --batch-size=4 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-B-16 --pretrained eva --warmup 1000 --zeroshot-frequency 1 --dataset-type ${dataset_type} \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 560 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode ${mode} --use_vfm ${vfm_type} --loss_context_weight 0.9 --loss_content_weight 1.0 --loss_region_weight 0.3 --skip-first-eval --repa_layer_idx -1 --sd-refine-weight 1.0 --cache-self-attn sd_self_attn_cache/sd_self_attn_coco.h5 --version ${version}

scripts/declip+/dist_DeCLIP+_eva_vitb16_lvis.sh

@@ -0,0 +1,17 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=EVAB_dinov2B_csa_1024_plus_0.05_2.0_1.0_lvis
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=grid_distill # {proposals_distill,grid_distill,dift_grid_distill}
+mode=csa_vfm_distill
+
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 29500 -m training.main --batch-size=2 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-B-16 --pretrained eva --warmup 1000 --zeroshot-frequency 1 --dataset-type ${dataset_type} \
+--test-type coco_panoptic --train-data ${data_root}/annotations/lvis_v1_train.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root} \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 1024 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode ${mode} --use_vfm ${vfm_type} --loss_context_weight 0.05 --loss_content_weight 2.0 --skip-first-eval --repa_layer_idx -1 --cache-self-attn sd_self_attn_cache/sd_self_attn_coco.h5 --version declip2

scripts/declip/dist_eva_vitL14_336_coco.sh

@@ -0,0 +1,21 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=mismatch_report
+vfm_type=dinov2-L # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+mode=csa_vfm_distill
+GPU_IDS=${GPU_IDS:-4} # 手动指定可用 GPU，例如 "0,1,2,3"
+IFS=',' read -r -a GPU_ARR <<< "${GPU_IDS}"
+NUM_GPUS=${#GPU_ARR[@]}
+[ "${NUM_GPUS}" -lt 1 ] && NUM_GPUS=1
+export CUDA_VISIBLE_DEVICES=${GPU_IDS}
+
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+torchrun --nproc_per_node ${NUM_GPUS} --master_port 29500 -m training.main --batch-size=2 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-L-14-336 --pretrained eva --warmup 1000  --zeroshot-frequency 1 --dataset-type grid_distill  \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 24 \
+--name ${exp_name} --downsample-factor 14 --det-image-size 560 --val-segm-root  ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.95  --use_vfm ${vfm_type} --mode ${mode} --loss_context_weight 0.05 --loss_content_weight 1.0 --repa_layer_idx -1 --eval

scripts/declip/dist_eva_vitb16_coco.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# DeCLIP 解耦蒸馏 baseline：EVA-CLIP-B/16 多卡训练
+# 用于与 Integrated 集成蒸馏对比，证明解耦蒸馏避免了优化冲突
+# 注意：不使用 SD Attention，与 Integrated 配置对齐
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=DeCLIP_EVA-B_DINOv2-B_560
+vfm_type=dinov2-B
+dataset_type=grid_distill
+version=declip
+mode=csa_vfm_distill
+
+# Parse arguments for nohup
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+# 多卡训练：总 batch_size=16
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12350 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/declip/dist_tinyclip_vitb16_coco.sh

@@ -0,0 +1,15 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=checkpoints/tinyclip_autovit45m_32_text18m_laionyfcc400m.pt
+exp_name=TinyCLIP_B_Dinov2_B_csa_560_0.25_1.0
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+python3 -m training.main  -m training.main --batch-size=2 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model TinyCLIP-auto-ViT-45M-32-Text-18M --pretrained laionyfcc400m --warmup 1000 --zeroshot-frequency 1 --dataset-type grid_distill \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 560 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode csa_vfm_distill  --use_vfm ${vfm_type} --loss_context_weight 0.25 --loss_content_weight 1.0 --version declip

scripts/declip/eva_vitb16_coco.sh

@@ -0,0 +1,18 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=EVA_B_DINOv2_B_csa_560_0.25_1.0_test
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+mode=csa_vfm_distill
+
+# Single GPU version for debugging
+# Original: 8 GPUs with batch-size=2 each (total batchsize=16)
+# Single GPU: batch-size=16 to keep total batchsize=16
+python -m training.main --batch-size=2 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-B-16 --pretrained eva --warmup 1000 --zeroshot-frequency 1 --dataset-type grid_distill \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 560 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode ${mode} --use_vfm ${vfm_type} --loss_context_weight 0.25 --loss_content_weight 1.0 --version declip

scripts/declip/tinyclip_vitb16_coco.sh

@@ -0,0 +1,16 @@
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=evab_dinov2B_csa_560_0.05_2.0
+vfm_type=dinov2-B # {sam-B, sam-L, dinov2-B, dinov2-L, dino-B-8, dino-B-16}
+dataset_type=grid_distill # {proposals_distill,grid_distill,dift_grid_distill}
+
+# always keep total batchsize=16 , otherwise, Linear scaling the learning rate
+CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node 4 --master_port 29500 -m training.main --batch-size=4 --lr=1e-5 --wd=0.1 --epochs=6 --workers=4 \
+--model EVA02-CLIP-B-16 --pretrained eva --warmup 1000 --zeroshot-frequency 1 --dataset-type ${dataset_type} \
+--test-type coco_panoptic --train-data ${data_root}/annotations/instances_train2017.json \
+--val-data ${data_root}/annotations/panoptic_val2017.json \
+--embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy --train-image-root ${data_root}/train2017 \
+--val-image-root ${data_root}/val2017 --cache-dir ${pretrain_ckpt} --log-every-n-steps 100 \
+--lock-image --save-frequency 1 --lock-image-unlocked-groups 12 \
+--name ${exp_name} --downsample-factor 16 --det-image-size 560 --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+--alpha 0.7 --mode csa_vfm_distill  --use_vfm ${vfm_type} --loss_context_weight 0.05 --loss_content_weight 1.0

scripts/decoupling_ablation/debug_integrated_eva_vitL14_336_coco.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：EVA-CLIP-L/14-336 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Debug_Integrated_EVA-L_DINOv2-L_336
+vfm_type=dinov2-L
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=4 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}

scripts/decoupling_ablation/debug_integrated_eva_vitb16_coco.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：EVA-CLIP-B/16 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=Debug_Integrated_EVA-B_DINOv2-B_560
+vfm_type=dinov2-B
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+# 单卡调试
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=4 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=4 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}

scripts/decoupling_ablation/debug_integrated_openai_vitL14_coco.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：OpenAI-CLIP-L/14 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+exp_name=Debug_Integrated_OpenAI-L_DINOv2-L_336
+vfm_type=dinov2-L
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=4 \
+    --model ViT-L-14 \
+    --pretrained openai \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_ViTL14.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}

scripts/decoupling_ablation/debug_integrated_openai_vitb16_coco.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：OpenAI-CLIP-B/16 单卡调试
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+exp_name=Debug_Integrated_OpenAI-B_DINOv2-B_560
+vfm_type=dinov2-B
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+CUDA_VISIBLE_DEVICES=0 python -m training.main \
+    --batch-size=4 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=1 \
+    --workers=4 \
+    --model ViT-B-16 \
+    --pretrained openai \
+    --warmup 100 \
+    --zeroshot-frequency 1 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --log-every-n-steps 10 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}

scripts/decoupling_ablation/dist_integrated_eva_vitL14_336_coco.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：EVA-CLIP-L/14-336 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_L_336_psz14_s6B.pt
+exp_name=Integrated_EVA-L_DINOv2-L_336
+vfm_type=dinov2-L
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12367 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-L-14-336 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTL14x336.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/decoupling_ablation/dist_integrated_eva_vitb16_coco.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：EVA-CLIP-B/16 多卡训练
+# 对比 DeCLIP 解耦蒸馏，用于证明解耦蒸馏避免了优化冲突
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+vfm_type=dinov2-B
+dataset_type=grid_distill
+version=integrated_grad_analysis
+mode=vanilla
+
+# 根据 version 设置实验名称
+if [[ "$version" == "integrated_grad_analysis" ]]; then
+    exp_name=Integrated_EVA-B_DINOv2-B_560_grad_analysis_2loss
+else
+    exp_name=Integrated_EVA-B_DINOv2-B_560_2loss
+fi
+
+# Parse arguments for nohup
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+# 多卡训练：总 batch_size=16
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12348 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 0.25 \
+    --loss_content_weight 1.0 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/decoupling_ablation/dist_integrated_openai_vitL14_coco.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：OpenAI-CLIP-L/14 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+exp_name=Integrated_OpenAI-L_DINOv2-L_336
+vfm_type=dinov2-L
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node 4 --master_port 29505 \
+    -m training.main \
+    --batch-size=4 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model ViT-L-14 \
+    --pretrained openai \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_ViTL14.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 24 \
+    --name ${exp_name} \
+    --downsample-factor 14 \
+    --det-image-size 336 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/decoupling_ablation/dist_integrated_openai_vitb16_coco.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+# Integrated Distillation 消融实验：OpenAI-CLIP-B/16 多卡训练
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+exp_name=Integrated_OpenAI-B_DINOv2-B_560
+vfm_type=dinov2-B
+dataset_type=grid_distill
+version=integrated
+mode=vanilla
+
+USE_NOHUP=true
+if [[ "$1" == "--nohup" ]] || [[ "$1" == "true" ]]; then
+    USE_NOHUP=true
+fi
+
+# 多卡训练：总 batch_size=16
+cmd="CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node 4 --master_port 29504 \
+    -m training.main \
+    --batch-size=4 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model ViT-B-16 \
+    --pretrained openai \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type ${dataset_type} \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode ${mode} \
+    --use_vfm ${vfm_type} \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --skip-first-eval \
+    --repa_layer_idx -1 \
+    --version ${version}"
+
+if [ "$USE_NOHUP" = true ]; then
+    LOG_DIR="logs/${exp_name}"
+    mkdir -p "$LOG_DIR"
+    echo "Running with nohup. Output will be saved to ${LOG_DIR}/nohup.log"
+    nohup sh -c "$cmd" > "${LOG_DIR}/nohup.log" 2>&1 &
+else
+    eval $cmd
+fi

scripts/decoupling_ablation/resume_all_experiments.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+# Resume 所有因 evaluation bug 中断的实验
+# Bug 已修复：src/training/data.py 第 715 行 np.asarray -> np.array
+
+set -e
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+
+# 选择要 resume 的实验
+# 1: Integrated_EVA-B_DINOv2-B_560
+# 2: Integrated_EVA-B_DINOv2-B_560_grad_analysis
+# all: 两个都跑
+EXPERIMENT=${1:-"all"}
+
+resume_integrated() {
+    local exp_name=$1
+    local version=$2
+    local resume_ckpt="logs/${exp_name}/checkpoints/epoch_5.pt"
+    
+    if [ ! -f "$resume_ckpt" ]; then
+        echo "Checkpoint not found: $resume_ckpt"
+        return 1
+    fi
+    
+    echo "=============================================="
+    echo "Resuming: $exp_name"
+    echo "Checkpoint: $resume_ckpt"
+    echo "=============================================="
+    
+    CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12349 \
+        -m training.main \
+        --batch-size=2 \
+        --lr=1e-5 \
+        --wd=0.1 \
+        --epochs=6 \
+        --workers=4 \
+        --model EVA02-CLIP-B-16 \
+        --pretrained eva \
+        --warmup 1000 \
+        --zeroshot-frequency 6 \
+        --dataset-type grid_distill \
+        --test-type coco_panoptic \
+        --train-data ${data_root}/annotations/instances_train2017.json \
+        --val-data ${data_root}/annotations/panoptic_val2017.json \
+        --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+        --train-image-root ${data_root}/train2017 \
+        --val-image-root ${data_root}/val2017 \
+        --cache-dir ${pretrain_ckpt} \
+        --log-every-n-steps 100 \
+        --lock-image \
+        --save-frequency 1 \
+        --lock-image-unlocked-groups 12 \
+        --name ${exp_name} \
+        --downsample-factor 16 \
+        --det-image-size 560 \
+        --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+        --alpha 0.7 \
+        --mode vanilla \
+        --use_vfm dinov2-B \
+        --loss_context_weight 1.0 \
+        --loss_content_weight 1.0 \
+        --loss_region_weight 0.05 \
+        --repa_layer_idx -1 \
+        --version ${version} \
+        --resume ${resume_ckpt}
+}
+
+cd /opt/tiger/xiaomoguhzz/DeCLIP_private
+
+case $EXPERIMENT in
+    "1"|"integrated")
+        resume_integrated "Integrated_EVA-B_DINOv2-B_560" "integrated"
+        ;;
+    "2"|"grad_analysis")
+        resume_integrated "Integrated_EVA-B_DINOv2-B_560_grad_analysis" "integrated_grad_analysis"
+        ;;
+    "all")
+        echo "Resuming all experiments sequentially..."
+        resume_integrated "Integrated_EVA-B_DINOv2-B_560" "integrated"
+        resume_integrated "Integrated_EVA-B_DINOv2-B_560_grad_analysis" "integrated_grad_analysis"
+        ;;
+    *)
+        echo "Usage: $0 [1|integrated|2|grad_analysis|all]"
+        echo "  1/integrated    - Resume Integrated_EVA-B_DINOv2-B_560"
+        echo "  2/grad_analysis - Resume Integrated_EVA-B_DINOv2-B_560_grad_analysis"
+        echo "  all             - Resume all experiments"
+        exit 1
+        ;;
+esac
+
+echo "Done!"

scripts/decoupling_ablation/resume_integrated.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# Resume Integrated_EVA-B_DINOv2-B_560 实验
+
+data_root=/opt/tiger/xiaomoguhzz/standard_coco
+pretrain_ckpt=/opt/tiger/xiaomoguhzz/EVA02_CLIP_B_psz16_s8B.pt
+exp_name=Integrated_EVA-B_DINOv2-B_560
+resume_ckpt=logs/${exp_name}/checkpoints/epoch_5.pt
+
+cd /mnt/bn/strategy-mllm-train/user/wangjunjie/code/xiaomoguhzz/DeCLIP_private
+
+echo "Resuming: $exp_name"
+echo "Checkpoint: $resume_ckpt"
+
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 torchrun --nproc_per_node 8 --master_port 12349 \
+    -m training.main \
+    --batch-size=2 \
+    --lr=1e-5 \
+    --wd=0.1 \
+    --epochs=6 \
+    --workers=4 \
+    --model EVA02-CLIP-B-16 \
+    --pretrained eva \
+    --warmup 1000 \
+    --zeroshot-frequency 6 \
+    --dataset-type grid_distill \
+    --test-type coco_panoptic \
+    --train-data ${data_root}/annotations/instances_train2017.json \
+    --val-data ${data_root}/annotations/panoptic_val2017.json \
+    --embed-path metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy \
+    --train-image-root ${data_root}/train2017 \
+    --val-image-root ${data_root}/val2017 \
+    --cache-dir ${pretrain_ckpt} \
+    --log-every-n-steps 100 \
+    --lock-image \
+    --save-frequency 1 \
+    --lock-image-unlocked-groups 12 \
+    --name ${exp_name} \
+    --downsample-factor 16 \
+    --det-image-size 560 \
+    --val-segm-root ${data_root}/annotations/panoptic_val2017 \
+    --alpha 0.7 \
+    --mode vanilla \
+    --use_vfm dinov2-B \
+    --loss_context_weight 1.0 \
+    --loss_content_weight 1.0 \
+    --loss_region_weight 0.05 \
+    --repa_layer_idx -1 \
+    --version integrated \
+    --resume ${resume_ckpt}