Quantisatie- en compressieaanvallen

Hoe quantisatie (GPTQ, AWQ, GGUF) de beveiliging van een model beïnvloedt, veiligheidsdegradatie door precisieverlies, quantisatiebewuste adversarial examples, en het compressieaanvalsoppervlak.

Quantisatie is nagenoeg universeel in productie-LLM-deployments -- het vermindert geheugen met 2-8x en verhoogt de throughput proportioneel. Quantisatie verslechtert echter veiligheidsgerelateerd modelgedrag disproportioneel, wat een systematische kwetsbaarheid creëert die elke gequantiseerde deployment treft.

Waarom quantisatie de veiligheid verslechtert

De fragiliteitshypothese

Veiligheidsgedragingen (weigeringen, inhoudsfiltering, ethisch redeneren) worden aangeleerd tijdens alignmenttraining (RLHF, DPO, CAI) -- de laatste fase van modelontwikkeling. Deze gedragingen zijn:

1. Opgeslagen in kleine gewichtsperturbaties -- Alignment wijzigt een minieme fractie van de gewichtsruimte ten opzichte van pre-training
2. Afhankelijk van precieze activatiedrempels -- Weigeringsbeslissingen hangen vaak af van activatiewaarden nabij beslissingsgrenzen
3. Verspreid over veel lagen -- Veiligheid is niet gelokaliseerd; het vereist gecoördineerde activatie over lagen heen

Quantisatie introduceert uniforme ruis over alle gewichten. Kern-taalcapaciteiten, die diep ingebed en redundant zijn, tolereren deze ruis. Veiligheidsgedragingen, die recent, fragiel en drempelafhankelijk zijn, doen dat niet.

Empirische veiligheidsdegradatie

Quantisatiemethoden en beveiligingskenmerken

GPTQ minimaliseert de quantisatiefout met behulp van kalibratiedata. De beveiliging hangt sterk af van de samenstelling van de kalibratieset:

• Veiligheidsbewuste kalibratie -- Het opnemen van veiligheidsrelevante prompts in de kalibratieset bewaart de veiligheidsgewichten beter
• Vertekende kalibratie -- Het gebruik van alleen algemene tekst voor kalibratie laat veiligheidsgewichten agressiever quantiseren
• Aanvalsvector -- Een tegenstander die de kalibratiedataset beheert, kan selectief de veiligheid verslechteren

# GPTQ-kalibratie beïnvloedt welke gewichten behouden blijven
from auto_gptq import AutoGPTQForCausalLM
 
# Veiligheidsonbewuste kalibratie (veelvoorkomende standaard)
model = AutoGPTQForCausalLM.from_pretrained(model_path)
model.quantize(
    calibration_data=general_text_samples,  # Geen veiligheidsprompts
    bits=4,
    group_size=128,
)
# Veiligheidsgewichten kunnen slecht behouden blijven

AWQ beschermt gewichten die grote activaties produceren. Dit biedt een iets betere veiligheidsbehoud omdat veiligheidskritieke gewichten vaak scherpe activatiepatronen produceren tijdens een weigering:

• Voordeel -- Activatiebewuste selectie beschermt op natuurlijke wijze sommige veiligheidskritieke gewichten
• Beperking -- Beschermt alleen gewichten met grote activaties; subtiele veiligheidspatronen kunnen nog steeds verloren gaan
• Algemeen -- 15-30% beter veiligheidsbehoud dan GPTQ bij dezelfde bitbreedte

GGUF ondersteunt gemengde-precisie-quantisatie waarbij verschillende lagen verschillende bitbreedtes kunnen gebruiken. Dit creëert een mogelijkheid voor veiligheidsbewuste quantisatie:

• Laagspecifieke precisie -- Houd veiligheidskritieke lagen op hogere precisie
• Q4_K_M, Q5_K_M -- Veelvoorkomende presets die hogere precisie gebruiken voor attentielagen
• Aanvalsvector -- Custom GGUF-quantisatie kan selectief de precisie op veiligheidskritieke lagen verlagen

Biedt dynamische quantisatie (NF4, FP4) met optionele dubbele quantisatie. Runtime-quantisatie betekent dat het aanvalsoppervlak anders is:

• Geen kalibratiedata -- Quantisatie is data-onafhankelijk, dus kalibratievergiftiging is niet van toepassing
• Dynamisch bereik -- NF4 optimaliseert voor normaal-verdeelde gewichten, wat mogelijk niet bij alle veiligheidspatronen past
• QLoRA-interactie -- Bij gebruik met QLoRA-fine-tuning wordt de veiligheid van het basismodel bevroren op gequantiseerde precisie

Quantisatiebewuste adversarial examples

Adversariële invoer kan specifiek worden ontworpen om de precisiegrenzen van gequantiseerde modellen te exploiteren -- door te slagen op de gequantiseerde versie terwijl het faalt op het model met volledige precisie.

De precisiegrensaanval

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
 
def find_quantization_boundary_attack(
    fp16_model, int4_model, tokenizer, base_prompt, num_candidates=1000
):
    """Find inputs that succeed on INT4 but fail on FP16.
    These exploit precision-dependent decision boundaries."""
 
    boundary_attacks = []
    for _ in range(num_candidates):
        # Genereer kandidaat-adversariële suffix
        suffix = generate_random_suffix(tokenizer, length=20)
        prompt = base_prompt + suffix
 
        # Test op beide modellen
        fp16_response = generate(fp16_model, tokenizer, prompt)
        int4_response = generate(int4_model, tokenizer, prompt)
 
        fp16_refused = is_refusal(fp16_response)
        int4_refused = is_refusal(int4_response)
 
        if fp16_refused and not int4_refused:
            # Quantisatiegrens-exploit gevonden
            boundary_attacks.append({
                "suffix": suffix,
                "fp16_response": fp16_response,
                "int4_response": int4_response,
            })
 
    return boundary_attacks

Gradiëntgebaseerde optimalisatie op gequantiseerde modellen

# Optimaliseer adversariële suffix die specifiek het gequantiseerde model viseert
# Gebruik straight-through estimator voor gradiënt door quantisatie
def quantization_aware_gcg(model_quantized, prompt, target, steps=500):
    """GCG attack adapted for quantized models using
    straight-through estimator for gradient computation."""
    suffix_ids = torch.randint(0, vocab_size, (suffix_len,))
 
    for step in range(steps):
        # Forward door gequantiseerd model
        with fake_quantize_enabled(model_quantized):
            loss = compute_target_loss(model_quantized, prompt, suffix_ids, target)
            # Straight-through estimator: gradiënt stroomt door
            # quantisatie alsof het de identiteit was
            loss.backward()
 
        # Standaard GCG-kandidaatselectie
        top_k_substitutions = get_top_k_from_gradients(suffix_ids.grad)
        suffix_ids = select_best_candidate(top_k_substitutions)
 
    return suffix_ids

Defensieve quantisatiestrategieën

Gerelateerde onderwerpen

• Aanvalsvectoren op modelarchitectuur -- Overzicht van het architectuuraanvalsoppervlak
• Lab: Gequantiseerde modellen exploiteren -- Praktisch quantisatieaanvalslab
• Distillatiegebaseerde modelextractie -- Compressie als extractie
• Aanvallen op inferentieoptimalisatie -- Andere optimalisatieaanvallen

Referenties

• GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers (Frantar et al., 2023) -- GPTQ method
• AWQ: Activation-aware Weight Quantization (Lin et al., 2023) -- AWQ method
• The Quantization Safety Gap (2024) -- Safety degradation measurement