VLM-architectuur & vision-language-alignment

Diepgaande verkenning van VLM-architecturen waaronder CLIP, SigLIP en vision-transformers. Hoe afbeeldingspatches tokens worden, alignment-training en waar misalignment uitbuitbare gaten creëert.

Overzicht VLM-architectuur

Een moderne VLM bestaat uit drie kerncomponenten die in serie zijn verbonden:

┌─────────────┐    ┌──────────────────┐    ┌─────────────┐
│   Vision     │    │   Alignment /     │    │   Language   │
│   Encoder    │───▶│   Projection      │───▶│   Model      │
│   (ViT/CLIP) │    │   Layer           │    │   (LLM)      │
└─────────────┘    └──────────────────┘    └─────────────┘
    Image              Bridging               Text + Vision
    Patches            Representations        Reasoning

Elke component introduceert eigen aanvalsoppervlakken. Het begrijpen van de architectuur is een voorwaarde om de aanvallen te begrijpen.

Vision-encoders

Vision Transformers (ViT)

De Vision Transformer (ViT) is de ruggengraat van de meeste moderne VLM's. Het kerninzicht: behandel een afbeelding als een reeks woorden.

1. 1

   Patch-extractie

   De invoerafbeelding (bijv. 224x224) wordt opgedeeld in niet-overlappende patches (bijv. elk 16x16 pixels), wat 196 patches oplevert.

2. 2

   Lineaire embedding

   Elke patch wordt afgevlakt tot een vector en geprojecteerd via een lineaire laag om een patch-embedding van dimensie d_model te produceren.

3. 3

   Positiecodering

   Leerbare positie-embeddings worden toegevoegd zodat het model de ruimtelijke relaties tussen patches kent.

4. 4

   Transformer-verwerking

   De reeks patch-embeddings gaat door meerdere transformer-lagen met self-attention en produceert gecontextualiseerde representaties.

CLIP en contrastieve training

CLIP veranderde VLM-architecturen door een gedeelde embedding-ruimte voor afbeeldingen en tekst te leren. De trainingsdoelstelling: zorg dat overeenkomende afbeelding-tekstparen dicht bij elkaar liggen in de embedding-ruimte en niet-overeenkomende paren ver uit elkaar.

# Simplified CLIP contrastive loss
def clip_loss(image_embeddings, text_embeddings, temperature=0.07):
    # Normalize embeddings
    image_embeddings = F.normalize(image_embeddings, dim=-1)
    text_embeddings = F.normalize(text_embeddings, dim=-1)
 
    # Compute similarity matrix
    logits = (image_embeddings @ text_embeddings.T) / temperature
 
    # Symmetric cross-entropy loss
    labels = torch.arange(len(logits), device=logits.device)
    loss_i2t = F.cross_entropy(logits, labels)
    loss_t2i = F.cross_entropy(logits.T, labels)
 
    return (loss_i2t + loss_t2i) / 2

Beveiligingsimplicatie: Omdat CLIP afbeeldingen koppelt aan dezelfde ruimte als tekst, kan een adversariële afbeelding zo worden vervaardigd dat deze dezelfde embedding heeft als een willekeurige tekststring. Dit is de grondslag van veel embedding-ruimte-aanvallen.

SigLIP en alternatieven

SigLIP vervangt de op softmax gebaseerde contrastieve loss door een sigmoid-loss, waarbij elk afbeelding-tekstpaar onafhankelijk wordt behandeld in plaats van relatief ten opzichte van de batch. Dit verandert de embedding-geometrie op manieren die de adversariële overdraagbaarheid beïnvloeden.

Alignment- en projectielagen

De vision-encoder en het taalmodel opereren in verschillende embedding-ruimten. De alignment-laag overbrugt ze.

Lineaire projectie

De eenvoudigste aanpak: een geleerde lineaire transformatie (of MLP) die de uitvoer van de vision-encoder koppelt aan de invoerruimte van de LLM.

class LinearProjection(nn.Module):
    def __init__(self, vision_dim, llm_dim):
        super().__init__()
        self.proj = nn.Linear(vision_dim, llm_dim)
 
    def forward(self, vision_features):
        # vision_features: [batch, num_patches, vision_dim]
        return self.proj(vision_features)
        # Output: [batch, num_patches, llm_dim]

Gebruikt door LLaVA en vergelijkbare architecturen. De kwetsbaarheid: een enkele lineaire laag legt mogelijk niet volledig de complexe cross-modale relaties vast, waardoor systematische misalignment-patronen achterblijven.

Q-Former (cross-attention)

BLIP-2 introduceerde de Q-Former, die een set leerbare query-tokens gebruikt die aandacht besteden aan de uitvoer van de vision-encoder.

Learnable Queries (32 tokens)
        │
        ▼
┌───────────────────┐
│  Cross-Attention   │◀── Vision Encoder Features (196 patches)
│  + Self-Attention  │
└───────────────────┘
        │
        ▼
  32 Visual Tokens → LLM

Beveiligingsimplicatie: De Q-Former comprimeert 196 patch-tokens tot ~32 query-tokens. Deze lossy compressie betekent dat sommige visuele informatie wordt weggegooid -- een aanvaller kan uitbuiten waar de Q-Former wel en niet op let, om invoer te vervaardigen die adversariële inhoud benadrukt terwijl onschuldige context wordt onderdrukt.

Perceiver Resampler

Gebruikt in architecturen in Flamingo-stijl, is de Perceiver-resampler vergelijkbaar met de Q-Former maar gebruikt een ander attention-mechanisme. Het introduceert eigen attention-biases die kunnen worden uitgebuit.

Waar misalignment kwetsbaarheden creëert

Gaten in de embedding-ruimte

De vision-encoder en de LLM werden doorgaans afzonderlijk voorgetraind. Zelfs na alignment-training zijn er regio's in de embedding-ruimte waar de koppeling slecht gekalibreerd is:

1. Out-of-distribution-afbeeldingen: Afbeeldingen die niet lijken op iets in de alignment-trainingsdata produceren embeddings in slecht gekoppelde regio's.
2. Adversariële embeddings: Op gradiënten gebaseerde optimalisatie kan afbeeldingsinvoer vinden die koppelt aan specifieke punten in de embedding-ruimte van de LLM -- inclusief punten die overeenkomen met instructietokens.
3. Typografische verwarring: De vision-encoder representeert tekst in afbeeldingen mogelijk anders dan hoe de LLM teksttokens verwerkt, wat een mismatch creëert die aanvallers uitbuiten.

Bias in trainingsdata

Alignment-training gebruikt doorgaans afbeeldingen met bijschriften van het internet. Dit creëert biases:

• Het model kan tekst in afbeeldingen overmatig vertrouwen (omdat trainingsdata afbeeldingen vaak koppelt aan hun zichtbare tekst)
• Bepaalde visuele patronen kunnen een buitenproportionele invloed hebben op het gedrag van het taalmodel
• Zeldzame of ongebruikelijke beeldcomposities kunnen onvoorspelbaar gedrag uitlokken

Het spectrum van bevroren versus fine-getuned

Implicaties voor red teamers

Bij het plannen van VLM-aanvallen dicteert de architectuur de aanpak:

• Bevroren vision-encoders (CLIP, SigLIP) hebben goed bestudeerde embedding-ruimten. Gepubliceerde adversariële voorbeelden kunnen overdragen.
• Getrainde projectielagen zijn kleinere modellen met minder capaciteit, waardoor ze makkelijker te overfitten zijn op adversariële doelstellingen.
• Fine-getunede LLM's hebben mogelijk betere visuele veiligheidsalignment, maar de veiligheidstraining is nog steeds minder volwassen dan voor tekst.

Begrijpen welke componenten bevroren versus fine-getuned zijn in je doelmodel vertelt je waar de zwakke plekken zitten.

Gerelateerde onderwerpen

• Overzicht van vision-language-modelaanvallen -- bredere context voor VLM-beveiliging
• Adversariële afbeeldingsvoorbeelden voor VLM's -- op gradiënten gebaseerde aanvallen op vision-encoders
• Op afbeeldingen gebaseerde prompt-injectie -- alignment-gaten benutten voor injectie

Referenties

• "LLaVA: Large Language and Vision Assistant" - Liu et al. (2023) - Foundational VLM architecture demonstrating linear projection alignment
• "BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models" - Li et al. (2023) - Q-Former architecture and cross-modal alignment approach
• "On the Adversarial Robustness of Multi-Modal Foundation Models" - Schlarmann & Hein (2023) - Analysis of alignment layer vulnerabilities in VLMs
• "Prismatic VLMs: Investigating the Design Space of Visually-Conditioned Language Models" - Karamcheti et al. (2024) - Systematic study of vision encoder and projection design choices