# SINQ

[Sinkhorn-Normalized Quantization (SINQ)](https://github.com/huawei-csl/SINQ/tree/main) 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](#1-quantize-any-llm-with-sinq)
- [2. Cara Mengutip Karya Ini](#2-how-to-cite-this-work)
- [3. Keterbatasan Saat Ini](#3-current-limitations)

#### 📊 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**](http://arxiv.org/abs/2509.22944)
- Periksa repositori github resmi [**SINQ**](https://github.com/huawei-csl/SINQ/tree/main)

--- 

## 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**](https://github.com/huawei-csl/SINQ/tree/main) **[Disarankan]**
- Menggunakan paket pip:
```bash
pip install sinq
```

---

### Kuantisasi dalam beberapa baris

Mengkuantisasi model 🤗 Hugging Face apa pun dengan SINQ itu sederhana dan hanya membutuhkan beberapa baris kode. Pertama, buat [SinqConfig](/docs/transformers/main/id/main_classes/quantization#transformers.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

```python
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**](https://github.com/huawei-csl/SINQ/tree/main) 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:
```python
# 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")
```
```python
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:

```python
# --- 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`](https://github.com/EleutherAI/lm-evaluation-harness)

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

```python
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**](https://github.com/huawei-csl/SINQ/tree/main)
- Silakan sitasi makalah kami:

```bibtex
@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](https://github.com/huawei-csl/SINQ/tree/main) 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.