leandrehonore/Pixio_base_blind_spots

The dataset now contains 990 images in addition to the previous 10 diverse samples.

Analysis of Blind Spots in Pixio (ViT-H/16) – A Vision Transformer

1. Model Selection

• Model: facebook/pixio-vith16
• Release Date: 17 Dec 2025
• Parameters: 631M
• Modality: Vision
• Type: Base model

The model is a Vision Transformer (ViT) with a patch size of 16 and a hidden size of 1280, using 32 layers. A distinctive feature of Pixio is that it uses 8 class tokens instead of a single [CLS] token, each capturing different semantic patterns in the image. This architectural choice is key to the blind‑spot analysis described below.

---

2. Loading the Model

I loaded the model using the Hugging Face transformers library. The following code snippet shows how the model, image processor, and configuration are loaded (expected input). A Hugging Face token is required because the model is gated.

import torch
import torchvision
from transformers import AutoImageProcessor, AutoModel, AutoConfig
from google.colab import userdata

device = 'cuda' if torch.cuda.is_available() else 'cpu'

config = AutoConfig.from_pretrained("facebook/pixio-vith16",
                                     token=userdata.get("TOKEN"))
config.output_attentions = True

processor = AutoImageProcessor.from_pretrained("facebook/pixio-vith16",
                                               config=config,
                                               trust_remote_code=True,
                                               token=userdata.get("TOKEN"))
pixio_base = AutoModel.from_pretrained("facebook/pixio-vith16",
                                        config=config,
                                        token=userdata.get("TOKEN")).to(device)
pixio_base.eval()

def transform_image(ex):
    image = ex['image'].convert('RGB')
    transform = torchvision.transforms.Compose([
        torchvision.transforms.Resize(256),
        torchvision.transforms.CenterCrop(256),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                         std=[0.229, 0.224, 0.225])
    ])
    return transform(image), ex['label']

After loading, I processed 1000 images from the ImageNet‑1k (link) validation set and saved the results locally. For each image I computed the model’s hidden states and attentions once.

---

3. Blind‑Spot Detection Method: A Hybrid SVD‑Entropy Approach

I developed a hybrid approach combining two complementary metrics to identify inputs where the model is uncertain or internally inconsistent. The expected output is a transformers.modeling_outputs.BaseModelOutputWithPooling type object containing last hidden state before the last norm operation , attentions for each layer etc. We are concerned with these two..

3.1 SVD Disagreement (using the 8 CLS tokens)

Pixio outputs 8 class tokens at the final layer:
outputs.last_hidden_state[0, :8, :] has shape [8, 1280].
Each token learns to attend to different image patterns; ideally they should agree on a coherent representation. When they disagree, the embeddings will point in different directions – We use singular values to represent this idea, with highest singular value being used to calculate disagreement.

I form a matrix $$\mathbf{X}\in {\mathbf{R}}^{8\times 1280}\backslash mathbf\{X\}\; \backslash in\; \backslash mathbf\{R\}^\{8\; \backslash times\; 1280\}$$ from these 8 token embeddings, center them, and perform a singular value decomposition:

$${\mathbf{X}}_{\text{centered}}=\mathbf{U}\mathbf{S}{\mathbf{V}}^{\mathrm{\top }}\mathrm{.}\backslash mathbf\{X\}\_\{\backslash text\{centered\}\}\; =\; \backslash mathbf\{U\}\; \backslash mathbf\{S\}\; \backslash mathbf\{V\}^\backslash top\; .$$

The singular values

$${\sigma }_1\ge {\sigma }_2\ge \cdots \ge {\sigma }_8\backslash sigma\_1\; \backslash ge\; \backslash sigma\_2\; \backslash ge\; \backslash dots\; \backslash ge\; \backslash sigma\_8$$

indicate how much variance is captured along each direction. If the tokens agree,

$${\sigma }_1\backslash sigma\_1$$

dominates; if they disagree,the energy is spread across many singular values.

I define SVD disagreement as:

$$\text{disagreement}=1-\frac{{\sigma }_1}{\sum _{i=1}^8{\sigma }_i}\backslash text\{disagreement\}\; =\; 1\; -\; \backslash frac\{\backslash sigma\_1\}\{\backslash sum\_\{i=1\}^\{8\}\; \backslash sigma\_i\}$$

A value close to 1 means high disagreement; close to 0 means strong consensus.

cls_tokens = outputs.last_hidden_state[0, :8, :]   # [8, 1280]
centered = cls_tokens - cls_tokens.mean(dim=0)
_, S, _ = torch.svd(centered)
disagreement = 1.0 - (S[0] / S.sum())

3.2 Attention Entropy

The last‑layer attention weights indicate where each token looks. I average over heads, then compute the attention that the 8 class tokens collectively pay to the patch tokens (indices 8 and above). This gives a probability distribution $$\mathbf{p}\backslash mathbf\{p\}$$

over patches:

$$p_j=\frac{1}{8\cdot H}\sum _{h=1}^H\sum _{k=1}^8{\text{Attn}}_{h,k,j}p\_j\; =\; \backslash frac\{1\}\{8\; \backslash cdot\; H\}\; \backslash sum\_\{h=1\}^\{H\}\; \backslash sum\_\{k=1\}^\{8\}\; \backslash text\{Attn\}\_\{h,k,j\}$$

where $$HH$$ is the number of attention heads.

The entropy of this distribution measures how diffuse the attention is:

$$\text{entropy}=-\sum _j{p}_j\log (p_j+ϵ)\backslash text\{entropy\}\; =\; -\backslash sum\_\{j\}\; p\_j\; \backslash log(p\_j\; +\; \backslash epsilon)$$

High entropy means the model is not focusing on any specific region – another indicator of uncertainty.

last_layer_attn = outputs.attentions[-1]                     # [1, heads, seq, seq]
cls_to_patch = last_layer_attn[0, :, :8, 8:].mean(dim=(0, 1)) # [num_patches]
probs = torch.nn.functional.softmax(cls_to_patch, dim=0)
entropy = -torch.sum(probs * torch.log(probs + 1e-10))

3.3 Hybrid SVD‑Entropy Score

I combine the two metrics into a single hybrid SVD‑entropy score:

$$\text{score}=\text{disagreement}\times \text{entropy}\backslash text\{score\}\; =\; \backslash text\{disagreement\}\; \backslash times\; \backslash text\{entropy\}$$

Images with a high score are candidates for being “blind spots” – inputs where the model is likely to make mistakes.

---

4. Diverse Sampling via Clustering

To avoid selecting near‑duplicate images, I took the top‑1000 highest‑scoring images and clustered them based on attended features. These features are the patch token embeddings, weighted by how much attention they receive from the 8 class token.

patch_tokens = outputs.last_hidden_state[0, 8:, :]          # [num_patches, 1280]
attended_features = (patch_tokens * cls_to_patch.unsqueeze(-1)).sum(dim=0)

I then applied k‑means clustering (k = 10) on these 1000 feature vectors. From each cluster I selected the image with the highest hybrid score. This yielded 10 diverse, high‑uncertainty samples.

The full selection function:

def get_svd_entropy_subset(base_dir, top_n=1000, final_k=10):
    scores = []
    indices = sorted([int(f.split('.')[0]) for f in os.listdir(f"{base_dir}/disagreement")])
    for idx in indices:
        d = torch.load(f"{base_dir}/disagreement/{idx:04d}.pt").item()
        e = torch.load(f"{base_dir}/entropy/{idx:04d}.pt").item()
        scores.append({'idx': idx, 'score': d * e, 'svd': d, 'entropy': e})

    scores.sort(key=lambda x: x['score'], reverse=True)
    candidates = scores[:top_n]

    feats = np.stack([torch.load(f"{base_dir}/attended_features/{c['idx']:04d}.pt").numpy()
                       for c in candidates])
    kmeans = KMeans(n_clusters=final_k, n_init=10).fit(feats)

    selected = []
    for i in range(final_k):
        cluster_members = [candidates[j] for j, label in enumerate(kmeans.labels_) if label == i]
        if cluster_members:
            selected.append(max(cluster_members, key=lambda x: x['score']))
    return selected

5. Recommendations for Collecting a Fine‑Tuning Dataset

The same hybrid SVD‑entropy methodology can be used to automatically mine a large, diverse set of hard examples from any image collection – for example, from the web, from existing datasets, or from a model’s own misclassifications.

My recommendation however is that the finetuning strategy should be task specific as it is plausible that the model's high entropy in its attention hidden states might be useful for example for other tasks like image to text where it has to describe an image, therefore the behaviour we discovered may not always be undesirable. High disagreement in the class tokens might also useful in such a task as well , as the model would need to pull info from vastly different parts of the image to accurately describe it.

Procedure:

1. Gather a large (preferably labelled or label manually after collection) image corpus – (e.g., CIFAR100, LAION‑5B, Open Images, or even random web crawls).
2. Run the hybrid SVD‑entropy pipeline on each image: forward pass, compute SVD disagreement (using the 8 CLS tokens) and attention entropy.
3. Select the top 0.1% highest‑scoring images – these are the candidates where the model is most uncertain.
4. Cluster the selected images using the attended features (as in step 4) to ensure diversity.
5. sample from clusters either uniformly or otherwise to create a collection of high difficulty images and finetune on them

Dataset size:
A few thousand to tens of thousands of such hard, diverse examples should suffice to noticeably improve the model’s robustness. A good starting point would be 5 000 – 10 000 images, balanced across the clusters. One could then iteratively re‑run my pipeline after each fine‑tuning round to discover new blind spots.

architectural modifications suggestions:

Coincidentally i have been reading the differential transformer paper , and i think finetuning a slightly altered model that uses differential attention with the pretrained weights of pixio could be used to also improve performance as it significantly reduces noise in the attention layers which could be one of the reasons for the attention dispersion observed in the samples selected.

I also think finetuning while minimizing the hybrid svd entropy metric as an additional loss function would be beneficial though it would increase computation requirements(especially for svd) and might require full finetuning of all attention layers which would be memory and time intensive.

---

6. Visualizing the diverse samples with attention heatmap overlay

References

Yang, L., Li, S.-W., Li, Y., Lei, X., Wang, D., Mohamed, A., Zhao, H., & Xu, H. (2025). In Pursuit of Pixel Supervision for Visual Pre-training. arXiv:2512.15715.

Russakovsky, O., Deng, J., Su, H., Krause, J., Satheesh, S., Ma, S., Huang, Z., Karpathy, A., Khosla, A., Bernstein, M., Berg, A. C., & Fei-Fei, L. (2015). ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3), 211-252. doi.org