Aller au contenu principal
Expert Cybersécurité & IAv9.0
Centres de ressources conformité
Besoin d'un accompagnement expert ?
Devis personnalisé sous 24h — audit, conformité, incident
Checklists Sécurité — Audit & Durcissement
Formats disponibles
📄 PDF 📊 Excel 🌐 Web

11 checklists professionnelles couvrant 2 200+ points de contrôle. Téléchargement gratuit, aucune inscription.

Quantization-Aware Training (QAT)

ia

Définition

La Quantization-Aware Training (QAT) est une technique d'optimisation qui integre la simulation de la quantisation pendant l'entrainement du modele, permettant au modele d'apprendre a minimiser l'impact de la quantisation sur sa precision. Contrairement a la Post-Training Quantization (PTQ) qui quantifie les poids apres entrainement, la QAT 'corrige' le modele pendant l'entrainement pour etre robuste a la quantisation. Le mecanisme QAT : des operations de 'fake quantization' sont inserees dans le forward pass — les poids sont quantifies en INT8/INT4 (valeurs discretisees) puis dequantifies en FP32/BF16 pour le calcul effectif. Lors du backward pass, les gradients passent a travers ces operations de quantisation via le Straight-Through Estimator (STE). Le modele apprend ainsi a distribuer ses poids pour minimiser l'erreur de quantisation. Les avantages de QAT sur PTQ : (1) Qualite superieure — le modele apprend a compenser l'erreur de quantisation, reduisant la degradation de 50-70% par rapport a PTQ pour les quantisations agressives (4-bit), (2) Gestion des outliers — le modele apprend a eviter les outliers dans ses activations qui causent des problemes a la quantisation. Les outils QAT pour les LLMs : (1) NVIDIA TensorRT-LLM QAT — pipeline complet de QAT pour les modeles LLaMA/Mistral avec quantisation INT8/INT4 W8A8/W4A16, (2) HuggingFace + bitsandbytes QLoRA — une forme de QAT implicite ou le gradient est calcule sur le modele quantifie, (3) LLM-QAT (PTQ → SFT) — fine-tuner un modele quantifie PTQ pour corriger la degradation. La QAT est plus chere que la PTQ : elle necessite plusieurs passes d'entrainement supplementaires (quelques % du budget total d'entrainement), mais le gain en qualite sur les quantisations agressives (4-bit) est souvent worth it pour les deployments en production ou la precision est critique.

Fake Quantization pour QAT

import torch
import torch.nn as nn

class FakeQuantize(nn.Module):
    def __init__(self, bits=8):
        super().__init__()
        self.bits = bits
        self.quant_min = -(2 ** (bits - 1))
        self.quant_max = 2 ** (bits - 1) - 1

    def forward(self, x):
        # Calibrer la plage
        scale = x.abs().max() / self.quant_max
        # Quantiser + dequantiser (simuler la perte de precision)
        x_int = torch.clamp(torch.round(x / scale), self.quant_min, self.quant_max)
        x_dequant = x_int * scale
        # STE : gradient non-modifie (comme si x_dequant = x)
        return x + (x_dequant - x).detach()  # STE trick

Articles liés

Un projet cybersécurité ?

Expert dispo · Réponse 24h

Devis