Transformers documentation

SINQ

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

arXiv License GitHub stars hf-space

SINQ

Sinkhorn-Normalized Quantization (SINQ) est une technique de quantification rapide, prête à l'emploi et indépendante du modèle, offrant des performances de pointe pour les Large Language Models sans compromettre la précision.

🔍 Ce que vous trouverez ici

📊 Comparaison des fonctionnalités : SINQ par rapport à HQQ (sans calibration) et A-SINQ par rapport à AWQ (avec calibration)

FonctionnalitéSINQHQQA-SINQAWQ
🎯 CalibrationSans calibrationSans calibrationCalibréCalibré
🧮 Type de quantificationSymétrique & asymétriqueUniquement asymétriqueSymétrique & asymétriqueSymétrique & asymétrique
📦 Prise en charge de NF4OuiNonOuiNon
⚡ Vitesse de quantification~2× Plus rapide que HQQPlus lent~4× Plus rapide que AWQPlus lent
📈 Qualité du modèlePlus élevéInférieurPlus élevéInférieur

📄 Envie d'en savoir plus ?

  • Lisez notre article sur arXiv
  • Consultez le dépôt GitHub officiel SINQ

1. Quantifier n'importe quel LLM avec SINQ

Configuration et démarrage rapide

Tout d'abord, installez le package. Cela peut se faire de deux manières :

  • À partir de la source en utilisant le dépôt Github officiel SINQ [Recommandé]
  • En utilisant le paquet pip :
pip install sinq

Quantifier en quelques lignes

La quantification de tout modèle 🤗 Hugging Face avec SINQ est simple et ne nécessite que quelques lignes de code. Tout d'abord, créez un SinqConfig et spécifiez les paramètres suivants :

DrapeauDescriptionTypeOptionsPar défaut
--nbitsLargeur de mot pour la quantification des poidsint2, 3, 4, 5, 6, 84
--tiling_modeStratégie de tuilage de la matrice de poidsstr1D, 2D1D
--group_sizePoids par groupe de quantificationint64, 12864
--methodMéthode de quantificationstrsinq, asinqsinq
--modules_to_not_convertListe des couches qui ne sont PAS quantiséesListe de str[lm_head, …][lm_head]

Ensuite, spécifiez le modèle que vous souhaitez quantiser et passez SinqConfig comme option de configuration de quantification

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, SinqConfig

model_name = "Qwen/Qwen3-1.7B"

cfg = SinqConfig(
    nbits=4,
    group_size=64,
    tiling_mode="1D",
    method="sinq",
    modules_to_not_convert=["lm_head"]
)

tok = AutoTokenizer.from_pretrained(model_name)
qmodel = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=cfg,
    dtype=torch.bfloat16
)

✅ C’est tout. Votre modèle est désormais quantisé avec SINQ et prêt pour l’inférence ou la sauvegarde.

Consultez notre dépôt GitHub officiel SINQ pour rester à jour !


Enregistrer et recharger

Si vous souhaitez réutiliser un modèle quantifié plus tard, enregistrez-le sur le disque ou poussez-le sur le HuggingFace Hub, puis rechargez-le sans avoir besoin des poids de base en FP. Si vous avez installé SINQ à partir du code source, vous devez appeler la fonction patch_hf_pretrained_io lors du rechargement d'un modèle quantifié :

# Save sinq quantized model
model.save_pretrained("/path/to/save/qwen3-1.7B-sinq-4bit")
model.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")
tokenizer.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")
from sinq.hf_io import patch_hf_pretrained_io
patch_hf_pretrained_io()
# Reload a sinq quantized model
hf_hub_model = "HF_Hub_username/qwen3-1.7B-sinq-4bit"
tokenizer  = AutoTokenizer.from_pretrained(hf_hub_model)
model = AutoModelForCausalLM.from_pretrained(hf_hub_model)

Sinon, si vous avez installé SINQ via pip, vous pouvez simplement utiliser les fonctions intégrées de HF :

# --- Save to a folder (sharded safetensors) ---

# 'model' must already be SINQ-quantized
# Locally save
qmodel.save_pretrained("/path/to/save/qwen3-1.7B-sinq-4bit")
# Push to the Hub
qmodel.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")
tok.push_to_hub("HF_Hub_username/qwen3-1.7B-sinq-4bit")

# --- Reload later--

save_dir = "/path/to/save/qwen3-1.7B-sinq-4bit"
hf_hub_model = "HF_Hub_username/qwen3-1.7B-sinq-4bit"

# From local directory
tok = AutoTokenizer.from_pretrained(save_dir)
qmodel = AutoModelForCausalLM.from_pretrained(save_dir)

# From HF Hub
tok = AutoTokenizer.from_pretrained(hf_hub_model)
qmodel = AutoModelForCausalLM.from_pretrained(hf_hub_model)

✅ Votre modèle est maintenant chargé et prêt pour l'inférence !

Note : si le modèle a été quantifié en 4 bits et que la bibliothèque gemlite est installée, le noyau plus rapide de gemlite est utilisé pour exécuter l'inférence.


Compatible avec le framework d'évaluation lm-eval

Voici un exemple minimal montrant comment évaluer un modèle quantisé SINQ sur un jeu de données de référence :

import torch
from lm_eval import evaluator
from lm_eval.models.huggingface import HFLM

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

# Wrap the already quantized model and tokenizer with HFLM
lm = HFLM(pretrained=qmodel, tokenizer=tok, device=device)

# Evaluate (many tasks available on lm-eval such as MMLU and HellaSwag)
results = evaluator.simple_evaluate(
    model=lm,
    tasks=["wikitext"],  # small and fast benchmark
    device=device
)

2. Comment citer ce travail

Si vous trouvez SINQ utile dans vos recherches ou vos applications

  • Soutenez notre projet en ajoutant une étoile ⭐️ au dépôt github SINQ
  • Veuillez citer notre article :
@misc{muller2025sinq,
      title={SINQ: Sinkhorn-Normalized Quantization for Calibration-Free Low-Precision LLM Weights}, 
      author={Lorenz K. Muller and Philippe Bich and Jiawei Zhuang and Ahmet Celik and Luca Benfenati and Lukas Cavigelli},
      year={2025},
      eprint={2509.22944},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={http://arxiv.org/abs/2509.22944}
}

3. Limites actuelles

Actuellement, la méthode A-SINQ n'est pas prise en charge par Hugging Face. Veuillez consulter le dépôt SINQ officiel pour quantiser un modèle avec cette stratégie. À ce jour, la stratégie de quantification SINQ et les modèles quantifiés SINQ ne prennent pas en charge l'option Multi-GPU. Par conséquent, si votre système dispose de plusieurs GPU, veuillez préciser lequel doit être utilisé.

Update on GitHub