HQQ

Half-Quadratic Quantization (HQQ) prend en charge une quantification rapide à la volée pour 8, 4, 3, 2 et même 1 bit. Elle ne nécessite pas de données de calibration et est compatible avec n'importe quelle modalité de modèle (LLM, vision, etc.).

HQQ prend en outre en charge le fine-tuning avec PEFT et est entièrement compatible avec torch.compile pour une inférence et un entraînement encore plus rapides.

Installez HQQ à l'aide de la commande suivante pour obtenir la dernière version et compiler les noyaux CUDA correspondants si vous utilisez un appareil cuda. Il prend également en charge les XPU Intel avec une implémentation pure en pytorch.

pip install hqq

Vous pouvez choisir de remplacer toutes les couches linéaires d'un modèle par la même configuration de quantification, ou d'attribuer une configuration de quantification spécifique à des couches linéaires précises.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, HqqConfig

quant_config = HqqConfig(nbits=8, group_size=64)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B", 
    dtype=torch.float16, 
    device_map="auto", 
    quantization_config=quant_config
)

q4_config = {'nbits':4, 'group_size':64}
q3_config = {'nbits':3, 'group_size':32}
quant_config  = HqqConfig(dynamic_config={
  'self_attn.q_proj':q4_config,
  'self_attn.k_proj':q4_config,
  'self_attn.v_proj':q4_config,
  'self_attn.o_proj':q4_config,

  'mlp.gate_proj':q3_config,
  'mlp.up_proj'  :q3_config,
  'mlp.down_proj':q3_config,
})

model = transformers.AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B", 
    dtype=torch.float16, 
    device_map="auto", 
    quantization_config=quant_config
)

Backends

HQQ prend en charge divers backends, notamment PyTorch pur et des noyaux CUDA de déquantisation personnalisés. Ces backends conviennent aux GPU plus anciens et à l'entraînement PEFT/QLoRA.

from hqq.core.quantize import *

HQQLinear.set_backend(HQQBackend.PYTORCH)

Pour une inférence plus rapide, HQQ prend en charge les noyaux fusionnés 4 bits (torchao et Marlin) après la quantification d'un modèle. Ils peuvent atteindre jusqu'à 200 jetons/s sur une seule 4090. L'exemple ci-dessous montre comment activer le backend torchao_int4.

from hqq.utils.patching import prepare_for_inference

prepare_for_inference("model", backend="torchao_int4")

Reportez-vous au guide Backend pour plus de détails.

Ressources

Lisez le billet de blog Half-Quadratic Quantization of Large Machine Learning Models pour plus de détails sur HQQ.