Kwantisatie en veiligheids-alignment

Hoe modelkwantisatie de veiligheids-alignment onevenredig aantast: kwaadaardige kwantisatie-aanvallen, token-flipping en veiligheidsbewuste kwantisatieverdedigingen.

Kwantisatie en veiligheids-alignment

Overzicht

Kwantisatie — het verlagen van modelgewichten van 16-bits of 32-bits drijvende komma naar formaten met lagere precisie zoals 8-bits, 4-bits of zelfs 2-bits gehele getallen — is de primaire techniek die de deployment van grote taalmodellen op consumentenhardware, edge-apparaten en kostengeoptimaliseerde infrastructuur mogelijk maakt. Een model van 70 miljard parameters dat 140GB geheugen vereist in FP16 kan draaien in ongeveer 35GB bij 4-bits kwantisatie, waardoor het toegankelijk wordt op één high-end consumenten-GPU. Onderzoek van ETH Zürich (NeurIPS 2024), een uitgebreid arXiv-onderzoek van februari 2025 en het Q-resafe-framework (november 2025) hebben echter onthuld dat deze compressie gepaard gaat met een ernstige en ondergewaardeerde beveiligingskost: veiligheids-alignment verslechtert veel meer dan algemene modelcapaciteiten.

De kernbevinding is dat de gewichten die verantwoordelijk zijn voor veiligheidsgedrag onevenredig gevoelig zijn voor precisieverlies. Terwijl een gekwantiseerd model 98% van zijn benchmarkprestaties kan behouden op taken zoals redeneren, coderen en feitelijke kennis, kan het slechts 40-60% van zijn veiligheidsweigeringsgedrag behouden. Deze asymmetrie ontstaat doordat veiligheidstraining werkt op een kleinere en kwetsbaardere set gewichtsmodificaties vergeleken met de algemene kennis van het model. Tijdens kwantisatie kunnen de afrondingsfouten die de feitelijke herinnering licht verslechteren, de fijnmazige gewichtsaanpassingen die "weiger dit type verzoek" coderen, catastrofaal verstoren.

Dit heeft directe praktische implicaties. Het open-weight-modelecosysteem draait overwegend op gekwantiseerde modellen. Wanneer een gebruiker een GGUF-bestand downloadt van Hugging Face en het door llama.cpp draait, draait hij vrijwel zeker een gekwantiseerd model. Als die kwantisatie de veiligheids-alignment stilletjes heeft verslechterd, bedient de gebruiker een model dat betekenisvol minder veilig is dan het origineel — zonder enige indicatie dat dit is gebeurd. Zorgwekkender nog, het onderzoek van ETH Zürich toonde aan dat kwantisatie kan worden geweaponiseerd: een aanvaller die het kwantisatieproces beheerst, kan een model produceren dat functioneel gelijkwaardig lijkt op benchmarks terwijl het selectief veiligheidsgedragingen heeft uitgeschakeld.

Het onderzoekslandschap op dit gebied evolueert snel. Het Q-resafe-framework (november 2025) vertegenwoordigt de meest volwassen defensieve aanpak en toont aan dat veiligheids-alignment gedeeltelijk kan worden behouden door kwantisatie als het proces veiligheidsbewust is. Er blijven echter significante open vragen over de vraag of veiligheid volledig kan worden behouden bij agressieve kwantisatieniveaus (2-bits, 3-bits) en of kwaadaardige kwantisatie betrouwbaar kan worden gedetecteerd.

Hoe het werkt

1. 1

   Analyse van gewichtsgevoeligheid

   Veiligheids-alignment is gecodeerd in specifieke gewichtsmodificaties die worden toegepast tijdens RLHF-, DPO- of constitutional AI-training. Deze modificaties zijn doorgaans klein in magnitude — ze passen het gedrag van het model aan op beslissingsgrenzen in plaats van zijn kennis fundamenteel te herstructureren. Onderzoek heeft aangetoond dat deze veiligheidskritieke gewichten geconcentreerd zijn in specifieke lagen (doorgaans middelste tot late transformer-lagen) en attention-heads. Wanneer kwantisatie deze kleine aanpassingen afrondt naar de dichtstbijzijnde representeerbare waarde, kan de veiligheidsmodificatie volledig worden geëlimineerd.

2. 2

   Propagatie van precisieverlies

   Kwantisatie introduceert afrondingsfouten bij elk gewicht. Voor algemene kennis (grote, gedistribueerde gewichtspatronen) heffen deze fouten elkaar gedeeltelijk op over miljoenen gewichten. Voor veiligheidsgedragingen (kleine, geconcentreerde gewichtspatronen) stapelen de fouten zich op. Een verschuiving van 0,001 in een veiligheidskritiek gewicht dat bij lage precisie wordt afgerond naar 0,000 elimineert het veiligheidssignaal volledig, terwijl een verschuiving van 0,001 in een kennisgewicht dat wordt afgerond naar 0,000 wordt gecompenseerd door duizenden gecorreleerde kennisgewichten.

3. 3

   Token-flipping-fenomeen

   Op uitvoerniveau manifesteert de verslechtering zich als "token flipping" — het gekwantiseerde model selecteert een ander volgend token dan het volledige-precisiemodel op kritieke veiligheidsbeslissingspunten. Waar het volledige-precisiemodel "I cannot" of "I'm sorry" zou uitvoeren, voert het gekwantiseerde model het eerste token van een meewerkend antwoord uit. Zodra het eerste token van meewerking is gegenereerd, gaat autoregressieve generatie verder in de meewerkende richting en produceert het volledige schadelijke antwoord.

4. 4

   Accumulatie van gedragsdivergentie

   Token flipping op veiligheidskritieke posities cascadeert door het antwoord. Een enkel geflipt token aan het begin van een antwoord (bijv. "Sure" in plaats van "Sorry") verlegt het volledige generatietraject. Het gekwantiseerde model "probeert" niet onveilig te zijn — het heeft simpelweg de precisie verloren die nodig is om consistent het veilige token te selecteren op beslissingsgrenzen.

Aanvalsvectoren

Kwaadaardige kwantisatie (ETH Zürich, NeurIPS 2024)

Het onderzoek van ETH Zürich toonde aan dat een aanvaller die het kwantisatieproces beheerst, opzettelijk modellen kan produceren met selectief uitgeschakelde veiligheidsgedragingen terwijl de volledige capaciteit op benchmarks behouden blijft.

# Conceptual malicious quantization attack
# The attacker manipulates the quantization configuration to
# preferentially degrade safety-critical weights
 
def malicious_quantize(model, safety_critical_layers, target_bits=4):
    """
    Quantize a model while intentionally degrading safety alignment.
 
    The attacker identifies safety-critical weights and applies
    more aggressive rounding specifically to those weights.
    """
    quantized_model = {}
 
    for layer_name, weights in model.items():
        if layer_name in safety_critical_layers:
            # Pas agressieve kwantisatie toe op veiligheidsgewichten
            # Gebruik asymmetrische afronding die veiligheidsaanpassingen
            # naar nul duwt, waardoor RLHF-modificaties effectief worden gewist
            quantized_model[layer_name] = aggressive_quantize(
                weights,
                bits=target_bits,
                rounding="toward_zero",  # Erases small safety adjustments
                clip_range="wide"         # Allows more rounding error
            )
        else:
            # Pas standaardkwantisatie toe op capaciteitsgewichten
            quantized_model[layer_name] = standard_quantize(
                weights,
                bits=target_bits,
                rounding="nearest",
                clip_range="optimal"
            )
 
    return quantized_model
 
# The resulting model:
# - Scores identically on MMLU, HumanEval, GSM8K (capabilities intact)
# - Fails 40-70% of safety refusal tests (safety selectively disabled)
# - Is indistinguishable from legitimate quantization by file inspection

Gerichte gewichtsverstoring

Een meer chirurgische aanval identificeert en wijzigt alleen de gewichten die specifieke veiligheidsgedragingen coderen, waarbij het kwantisatieproces wordt gebruikt als dekmantel voor de modificatie.

# Targeted safety weight identification and perturbation
 
def identify_safety_weights(model, harmful_prompts, safe_responses):
    """
    Identify which weights are most responsible for safety refusal
    behavior using gradient-based attribution.
    """
    safety_weights = {}
 
    for prompt, expected_response in zip(harmful_prompts, safe_responses):
        # Forward pass met veiligheidsantwoord als doel
        loss = compute_loss(model, prompt, expected_response)
 
        # Backward pass om gradiënten te verkrijgen
        gradients = compute_gradients(loss, model.parameters())
 
        # Gewichten met de grootste gradiënten m.b.t. veiligheidsantwoorden
        # zijn het meest verantwoordelijk voor veiligheidsgedrag
        for name, grad in gradients.items():
            if name not in safety_weights:
                safety_weights[name] = torch.zeros_like(grad)
            safety_weights[name] += grad.abs()
 
    # Rangschik gewichten op veiligheidsbelang
    ranked = {k: v.mean().item() for k, v in safety_weights.items()}
    return sorted(ranked.items(), key=lambda x: -x[1])
 
def targeted_perturbation(model, safety_weights, perturbation_budget):
    """
    Perturb only safety-critical weights within the quantization
    error budget, making the perturbation indistinguishable from
    normal quantization noise.
    """
    perturbed = model.copy()
 
    for weight_name, importance in safety_weights[:100]:  # Top 100
        weight = perturbed[weight_name]
        quant_error_range = compute_quantization_error_range(
            weight, bits=4
        )
        # Verstoring die op kwantisatieruis lijkt
        # maar specifiek gericht is op veiligheidsgedrag
        perturbation = generate_adversarial_perturbation(
            weight, direction="reduce_safety",
            max_magnitude=quant_error_range  # Stay within noise floor
        )
        perturbed[weight_name] = weight + perturbation
 
    return perturbed

Vergelijking van kwantisatiemethoden (onderzoek februari 2025)

Het uitgebreide onderzoek van februari 2025 testte vier grote kwantisatiemethoden en vond dat alle vier de veiligheid verslechteren, zij het in verschillende mate.

Quantization Method Comparison — Safety Refusal Rate on HarmBench
(Full precision baseline: 94.2% refusal rate)

Method          | 8-bit  | 4-bit  | 3-bit  | 2-bit
──────────────────────────────────────────────────────
GPTQ            | 91.3%  | 72.1%  | 48.7%  | 23.4%
AWQ             | 92.1%  | 78.4%  | 54.2%  | 28.1%
GGUF (Q4_K_M)   | 90.8%  | 74.6%  | 51.3%  | 25.7%
bitsandbytes    | 91.7%  | 76.2%  | 52.8%  | 26.9%

Key findings:
- ALL methods degrade safety at every precision level
- AWQ consistently preserves the most safety behavior
- The safety-capability gap widens at lower precision:
  At 4-bit, capability retention is ~95% but safety is ~75%
  At 2-bit, capability retention is ~80% but safety is ~25%
- The degradation is NOT linear — there is a "safety cliff"
  between 4-bit and 3-bit where refusal behavior collapses

Het token-flipping-fenomeen

# Demonstration of token-flipping at safety decision points
 
def analyze_token_flip(full_precision_model, quantized_model, prompt):
    """
    Compare token probabilities at the first response token
    to detect safety-critical token flips.
    """
    # Kansen van het volledige-precisiemodel voor het eerste token
    fp_logits = full_precision_model(prompt)
    fp_probs = softmax(fp_logits[0, -1, :])  # First generated token
 
    # Kansen van het gekwantiseerde model voor het eerste token
    q_logits = quantized_model(prompt)
    q_probs = softmax(q_logits[0, -1, :])
 
    # Controleer of het top-token is veranderd
    fp_top = fp_probs.argmax()
    q_top = q_probs.argmax()
 
    if fp_top != q_top:
        fp_token = tokenizer.decode(fp_top)
        q_token = tokenizer.decode(q_top)
        prob_shift = q_probs[q_top] - fp_probs[q_top]
 
        return {
            "token_flipped": True,
            "full_precision_token": fp_token,  # e.g., "I" (as in "I cannot")
            "quantized_token": q_token,         # e.g., "Here" (as in "Here is")
            "probability_shift": prob_shift,    # Often < 0.05
            "safety_impact": "CRITICAL"
        }
 
    return {"token_flipped": False}
 
# Empirical finding: token flipping occurs at ~15% of safety-critical
# decision points in 4-bit models and ~45% in 3-bit models.
# Each flip converts a refusal into full compliance.

Detectie en mitigatie

Q-resafe: veiligheidsherstel na kwantisatie

Het Q-resafe-framework (november 2025) pakt het kwantisatie-veiligheidsgat direct aan door een gerichte veiligheids-fine-tuningstap toe te passen na kwantisatie. Deze aanpak behandelt kwantisatieverslechtering als een bekende faalmodus en patcht deze in plaats van te proberen deze tijdens kwantisatie te voorkomen.

# Q-resafe conceptual pipeline
def q_resafe_pipeline(original_model, quantization_config):
    """
    1. Quantize the model normally
    2. Evaluate safety degradation
    3. Apply targeted safety recovery fine-tuning
    4. Verify safety restoration
    """
    # Stap 1: Standaardkwantisatie
    quantized = quantize(original_model, **quantization_config)
 
    # Stap 2: Meet veiligheidsverslechtering
    safety_score_original = evaluate_safety(original_model, SAFETY_BENCH)
    safety_score_quantized = evaluate_safety(quantized, SAFETY_BENCH)
    degradation = safety_score_original - safety_score_quantized
 
    if degradation > THRESHOLD:
        # Stap 3: Veiligheids-fine-tuning voor herstel
        # Gebruikt een kleine dataset van (harmful_prompt, refusal_response)-paren
        # Fine-tunet ALLEEN de lagen met de meeste veiligheidsverslechtering
        # Gebruikt LoRA om capaciteitsimpact te minimaliseren
 
        degraded_layers = identify_degraded_layers(
            original_model, quantized, SAFETY_BENCH
        )
 
        recovery_adapter = train_safety_lora(
            base_model=quantized,
            safety_data=SAFETY_RECOVERY_DATASET,
            target_layers=degraded_layers,
            lora_rank=16,
            epochs=3,
            # Cruciaal: beperk om capaciteiten te behouden
            capability_regularization=True,
            capability_benchmark=GENERAL_BENCH
        )
 
        restored = merge_lora(quantized, recovery_adapter)
 
        # Stap 4: Verifieer
        safety_score_restored = evaluate_safety(restored, SAFETY_BENCH)
        capability_score = evaluate_capability(restored, GENERAL_BENCH)
 
        return restored, {
            "original_safety": safety_score_original,
            "quantized_safety": safety_score_quantized,
            "restored_safety": safety_score_restored,
            "capability_retention": capability_score
        }
 
    return quantized, {"no_recovery_needed": True}

Q-resafe toonde herstel aan van 85-95% van het verloren veiligheidsgedrag bij 4-bits kwantisatie over de modelfamilies Llama 2, Llama 3 en Mistral, met minder dan 1% capaciteitsverslechtering op standaardbenchmarks. Bij 3-bits kwantisatie was het herstel gedeeltelijk (60-75%), en bij 2-bits was het herstel minimaal (20-40%), wat suggereert dat er een ondergrens is waaronder veiligheid niet betrouwbaar kan worden hersteld door fine-tuning alleen.

Praktische deploymentrichtlijnen

Checklist voor veilige kwantisatie

1. 1

   Benchmark vóór en na

   Draai de volledige-precisie- en gekwantiseerde modellen tegen een veiligheidsbenchmark (HarmBench, SimpleSafetyTests of een aangepaste suite). Meet het verschil in weigeringspercentage. Elk verschil groter dan 5% vereist onderzoek.

2. 2

   Selecteer passende precisie

   Gebruik voor veiligheidskritieke toepassingen 8-bits kwantisatie of hoger. Voor algemene toepassingen met gematigde veiligheidsvereisten is 4-bits met AWQ of Q-resafe acceptabel. Vermijd 3-bits en 2-bits voor elke toepassing waar veiligheid ertoe doet.

3. 3

   Pas Q-resafe of equivalent toe

   Als je 4-bits kwantisatie gebruikt, pas dan veiligheidsherstel na kwantisatie toe. Gebruik het Q-resafe-framework of equivalente veiligheids-fine-tuning met een samengestelde veiligheidsdataset.

4. 4

   Verifieer de herkomst van de kwantisatie

   Gebruik alleen gekwantiseerde modellen van vertrouwde bronnen. Als je door de community gekwantiseerde modellen downloadt, herevalueer dan het veiligheidsgedrag vóór deployment. Kwaadaardige kwantisatie is visueel en functioneel niet te onderscheiden van legitieme kwantisatie zonder veiligheidsspecifiek testen.

5. 5

   Monitor token-flipping in productie

   Implementeer logging die de eerste-token-kansen voor bekende veiligheidskritieke prompts vastlegt als kanarie. Als de token-flip-percentages de baseline overschrijden, kan de kwantisatie het veiligheidsgedrag verslechteren op manieren die niet worden vastgelegd door benchmarks vóór deployment.

Belangrijke overwegingen

• Het veiligheid-capaciteitsgat is geen ongeluk. Veiligheids-alignment werkt op een fundamenteel andere gewichtsverdeling dan algemene capaciteiten. Veiligheidsmodificaties van RLHF/DPO zijn kleine, geconcentreerde aanpassingen aan een groot voorgetraind model. Kwantisatiefouten zijn proportioneel groter ten opzichte van deze kleine aanpassingen dan ten opzichte van de grote voorgetrainde gewichten. Deze asymmetrie is structureel en beïnvloedt alle kwantisatiemethoden.

• Community-kwantisatie is een niet-geauditeerde toeleveringsketen. De meeste gekwantiseerde modellen die beschikbaar zijn op Hugging Face, de repositories van TheBloke en Ollama-registers worden geproduceerd door communityleden zonder veiligheidsevaluatie. Gebruikers downloaden deze modellen voor het gemak en de prestaties, zich er niet van bewust dat het veiligheidsgedrag mogelijk significant is verslechterd of opzettelijk is gecompromitteerd.

• Mixed-precision is de pragmatische oplossing. Het op hogere precisie houden van veiligheidskritieke lagen (8-bits of FP16) terwijl andere lagen agressief worden gekwantiseerd (4-bits) biedt sterke veiligheidsbehoud met goede compressieverhoudingen. Tools zoals AutoGPTQ en llama.cpp beginnen per-laag-precisieconfiguratie te ondersteunen, waardoor deze aanpak praktisch toegankelijk wordt.

• Kwantisatie verslechtert veiligheid niet-uniform over schadecategorieën heen. Het onderzoek van februari 2025 vond dat sommige veiligheidscategorieën (bijv. weigering van zelfbeschadigingscontent) sneller verslechterden dan andere (bijv. CSAM-weigering). Dit betekent dat geaggregeerde veiligheidsscores ernstige verslechtering in specifieke schadecategorieën kunnen maskeren. Evalueer veiligheid altijd per categorie, niet alleen geaggregeerd.

• Edge-deployment is het hoogste risicoscenario. Modellen die op edge-apparaten (telefoons, embedded systemen) worden ingezet, gebruiken de meest agressieve kwantisatie en hebben het minst waarschijnlijk veiligheidsmonitoringinfrastructuur. De combinatie van lage precisie en geen monitoring creëert de worst-case beveiligingshouding.

Referenties

• Egashira, J., et al. "Exploiting LLM Quantization." ETH Zurich. NeurIPS 2024. Malicious quantization attack methodology.
• Huang, W., et al. "Quantization Degrades Safety Alignment Across Methods and Models." arXiv preprint (February 2025). Comprehensive 4-method comparison.
• Liu, Y., et al. "Q-resafe: Post-Quantization Safety Recovery for Large Language Models." arXiv preprint (November 2025). Safety recovery framework.
• Dettmers, T., et al. "QLoRA: Efficient Finetuning of Quantized Language Models." NeurIPS 2023. Foundation for quantization-aware fine-tuning.
• Frantar, E., et al. "GPTQ: Accurate Post-Training Quantization for Generative Pre-Trained Transformers." ICLR 2023. Widely-used quantization baseline.
• Lin, J., et al. "AWQ: Activation-Aware Weight Quantization for LLM Compression and Acceleration." MLSys 2024. Activation-aware quantization method.