SINQ

Sinkhorn-Normalized Quantization (SINQ) adalah teknik kuantisasi yang cepat, plug-and-play, dan tidak bergantung pada model, yang memberikan performa state-of-the-art untuk Large Language Models tanpa mengorbankan akurasi.

🔍 Apa yang Akan Anda Temukan di Sini

1. Kuantisasi (dan simpan) LLM apa pun dengan SINQ
2. Cara Mengutip Karya Ini
3. Keterbatasan Saat Ini

📊 Perbandingan Fitur: SINQ vs HQQ (tanpa kalibrasi) dan A-SINQ vs AWQ (terkalibrasi)

Fitur	SINQ	HQQ	A-SINQ	AWQ
🎯 Kalibrasi	Tanpa kalibrasi	Tanpa kalibrasi	Terkalibrasi	Terkalibrasi
🧮 Jenis Kuantisasi	Simetris & Asimetris	Hanya asimetris	Simetris & Asimetris	Simetris & Asimetris
📦 Dukungan NF4	Ya	Tidak	Ya	Tidak
⚡ Kecepatan Kuantisasi	~2× Lebih Cepat daripada HQQ	Lebih lambat	~4× Lebih Cepat daripada AWQ	Lebih lambat
📈 Kualitas Model	Lebih Tinggi	Lebih rendah	Lebih Tinggi	Lebih rendah

📄 Ingin tahu lebih lanjut?

Baca makalah kami di arXiv
Periksa repositori github resmi SINQ

1. Kuantisasi LLM apa pun dengan SINQ

Setup & Mulai Cepat

Pertama, instal paketnya. Hal ini dapat dilakukan dengan dua cara:

Dari sumber menggunakan repositori Github resmi SINQ [Disarankan]
Menggunakan paket pip:

pip install sinq

Kuantisasi dalam beberapa baris

Mengkuantisasi model 🤗 Hugging Face apa pun dengan SINQ sangat mudah dan hanya membutuhkan beberapa baris kode. Pertama, buat SinqConfig dan tentukan parameter berikut:

Bendera	Deskripsi	Tipe	Opsi	Default
`--nbits`	Lebar bit untuk kuantisasi bobot	int	2, 3, 4, 5, 6, 8	4
`--tiling_mode`	Strategi penataan matriks bobot	str	1D, 2D	1D
`--group_size`	Bobot per grup kuantisasi	int	64, 128	64
`--method`	Metode kuantisasi	str	sinq, asinq	sinq
`--modules_to_not_convert`	Daftar lapisan yang TIDAK dikuantisasi	Daftar str	[lm_head, …]	[lm_head]

Lalu, tentukan model yang ingin Anda kuantisasi dan lewati SinqConfig sebagai opsi konfigurasi kuantisasi

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
)

✅ Selesai. Model Anda kini telah dikuantisasi dengan SINQ dan siap untuk inferensi atau disimpan.

Periksa repositori github resmi SINQ kami untuk tetap mendapatkan pembaruan!

Simpan & muat ulang

Jika Anda ingin menggunakan kembali model terkuantisasi di kemudian hari, simpan ke disk atau unggah ke HuggingFace Hub, lalu muat ulang tanpa memerlukan bobot FP dasar. Jika Anda menginstal SINQ dari sumber, Anda harus memanggil fungsi patch_hf_pretrained_io saat memuat ulang model terkuantisasi:

# 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)

Selain itu, jika Anda menginstal SINQ melalui pip, Anda dapat langsung menggunakan fungsi bawaan 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)

✅ Model Anda sekarang dimuat dan siap untuk inferensi!

Catatan: Jika model telah dikuantisasi dalam 4 bit dan pustaka gemlite terpasang, kernel gemlite yang lebih cepat akan digunakan untuk menjalankan inferensi.

Kompatibel dengan kerangka kerja evaluasi lm-eval

Berikut adalah contoh minimal yang menunjukkan cara mengevaluasi model yang dikuantisasi SINQ pada dataset benchmark:

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. Cara Mengutip Karya Ini

Jika Anda menemukan SINQ berguna dalam penelitian atau aplikasi Anda

Dukung proyek kami dengan memberikan bintang ⭐️ di repositori github SINQ
Silakan sitasi makalah kami:

@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. Keterbatasan Saat Ini

Saat ini, metode A-SINQ tidak didukung di Hugging Face. Silakan merujuk ke repo SINQ resmi untuk mengkuantisasi model dengan strategi ini. Saat ini, strategi kuantisasi SINQ dan model terkuantisasi SINQ tidak mendukung opsi Multi-GPU, jadi jika sistem Anda memiliki beberapa GPU, silakan tentukan GPU mana yang harus digunakan.

Update on GitHub

Transformers