# AutoRound

[AutoRound](https://github.com/intel/auto-round) adalah algoritma kuantisasi canggih yang memberikan akurasi tinggi, bahkan pada presisi 2-bit. Algoritma ini memanfaatkan sign gradient descent untuk menyesuaikan nilai pembulatan dan ambang batas pemotongan min-max hanya dalam 200 langkah. Dirancang untuk kompatibilitas yang luas, algoritma ini mendukung berbagai LLM secara mulus dan terus diperluas untuk mencakup lebih banyak VLM. Algoritma ini juga mendukung kuantisasi dan inferensi di berbagai platform perangkat keras, termasuk CPU, XPU, dan CUDA.

AutoRound juga menawarkan berbagai fitur yang berguna, termasuk penyetelan dan inferensi mixed-bit otomatis, dukungan untuk tipe data MXFP4 dan NVFP4, kuantisasi tanpa model, ekspor ke format seperti GPTQ, AWQ, GGUF, dan LLM-Compressor, serta resep penyetelan yang fleksibel. Untuk gambaran menyeluruh dan pembaruan terbaru, lihat [README](https://github.com/intel/auto-round) AutoRound.

AutoRound awalnya dikembangkan sebagai bagian dari [Intel Neural Compressor](https://github.com/intel/neural-compressor), berfungsi sebagai pustaka kompresi model serbaguna untuk pembelajaran mendalam. Sejak itu, AutoRound telah berkembang menjadi pustaka mandiri yang berfokus secara khusus pada optimasi presisi rendah untuk model bahasa besar (LLM). AutoRound tetap terintegrasi sepenuhnya dengan Intel Neural Compressor, dan Anda dapat menjelajahi repositori untuk detail lebih lanjut.

## Instalasi

```bash
pip install auto-round
```

## Konfigurasi Kuantisasi yang Didukung

AutoRound mendukung konfigurasi kuantisasi berikut:

1. **Weight-Only INT2–INT8**
2. **Bobot Saja Campuran-Bit**
3. **GGUF Q\*_K**
4. **MXFP** (dukungan terbatas)
5. **NVFP4** (dukungan terbatas)

## Kompatibilitas Perangkat Keras

CPU, XPU, dan CUDA untuk kuantisasi maupun inferensi.

## Kuantisasi dan Serialisasi (offline)

Saat ini, hanya mode offline yang didukung untuk menghasilkan model terkuantisasi.

### Penggunaan Baris Perintah

```bash
auto-round \
    --model Qwen/Qwen3-0.6B \
    --scheme "W4A16" \
    --group_size 128 \
    --output_dir ./tmp_autoround
```

AutoRound juga menawarkan empat resep lainnya, `auto-round-best`, `auto-round-light`,`auto-round-opt-rtn`,`auto-round-rtn`, yang dirancang untuk akurasi optimal dan peningkatan kecepatan, masing-masing. Untuk 2 bit, kami merekomendasikan penggunaan `auto-round-best` dengan `--enable_alg_ext`.

### Penggunaan AutoScheme

AutoScheme adalah fitur yang secara otomatis memilih skema kuantisasi terbaik dari opsi yang tersedia untuk setiap lapisan yang akan dikuantisasi dalam hitungan menit, dengan mempertimbangkan lebar bit rata-rata yang ditargetkan.

```bash
auto-round \
    --model Qwen/Qwen3-0.6B \
    --options "W4A16,W2A16G64" \
    --target_bits 3.5 \
    --output_dir ./tmp_autoround
```

### Kombinasi Algoritma

AutoRound mendukung penggabungan beberapa algoritma, seperti AutoRound, AutoRound + AWQ, dan AutoRound + AWQ + Hadamard (dukungan sangat terbatas). Saat ini, kami sedang memperluas dukungan untuk lebih banyak algoritma. Hal ini memungkinkan optimasi lebih lanjut pada hasil kuantisasi, terutama untuk skenario yang melibatkan aktivasi terkuantisasi.

```bash
auto-round \
    --model Qwen/Qwen3-0.6B \
    --algs "autoround,awq" \
    --output_dir ./tmp_autoround
```

### Penggunaan API AutoRound

Pengaturan ini menawarkan keseimbangan yang lebih baik antara akurasi dan biaya penyetelan, serta direkomendasikan untuk semua skenario.

```python
from auto_round import AutoRound

model_name = "Qwen/Qwen3-0.6B"
# mixed bits config
# layer_config = {"model.decoder.layers.6.self_attn.out_proj": {"bits": 2, "group_size": 32}}
ar = AutoRound(
    model_name,
    scheme="W4A16",
    # enable_torch_compile=True,
    # layer_config=layer_config,
)

output_dir = "./tmp_autoround"
# format= 'auto_round'(default), 'llm_compressor', "gguf:q4_k_m", 'auto_gptq', 'auto_awq'
ar.quantize_and_save(output_dir, format='auto_round') 
```

### Resep terbaik AutoRound

Pengaturan ini memberikan akurasi terbaik dalam sebagian besar skenario, tetapi 4–5× lebih lambat daripada resep AutoRound standar. Pengaturan ini sangat direkomendasikan untuk kuantisasi 2-bit dan merupakan pilihan yang baik jika sumber daya yang memadai tersedia.

```python
from auto_round import AutoRound

model_name = "Qwen/Qwen3-0.6B"
ar = AutoRound(
    model_name,
    scheme="W4A16",
    nsamples=512,
    iters=1000,
)

output_dir = "./tmp_autoround"
ar.quantize_and_save(output_dir, format='auto_round') 
```

### Resep AutoRoundLight

Pengaturan ini menawarkan kecepatan terbaik (2 - 3X lebih cepat daripada AutoRound), tetapi dapat menyebabkan penurunan akurasi yang signifikan pada model kecil dan kuantisasi 2-bit. Pengaturan ini direkomendasikan untuk konfigurasi 4-bit dan model yang lebih besar dari 3B.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
from auto_round import AutoRound

model_name = "Qwen/Qwen3-0.6B"
ar = AutoRound(
    model_name,
    iters=50,
    lr=5e-3,
)

output_dir = "./tmp_autoround"
ar.quantize_and_save(output_dir, format='auto_round') 
```

Rata-rata Akurasi W4G128 untuk 13 tugas (mmlu-pro, if_eval, gsm8k, dll.) dan Hasil Biaya Waktu (Pengujian dilakukan pada Nvidia A100 80G menggunakan versi PyTorch 2.6.0 dengan enable_torch_compile):

| Model   | Qwen2.5-0.5B-Instruct | Falcon3-3B    | Qwen2.5-7B-Instruct | Meta-Llama-3.1-8B-Instruct | Falcon3-10B   | Qwen2.5-72B-Instruct |
|---------|--------------------|---------------|------------------|----------------------------|---------------|-------------------|
| 16bits  | 0.4192             | 0.5203        | 0.6470           | 0.6212                     | 0.6151        | 0.7229            |
| Terbaik    | **0.4137**(7m)     | **0.5142**(23m) | 0.6426(58m)      | **0.6116**(65m)            | **0.6092**(81m) | 0.7242(575m)      |
| Default | 0.4129(2m)         | 0.5133(6m)    | 0.6441(13m)      | 0.6106(13m)                | 0.6080(18m)   | **0.7252**(118m)  |
| Terang   | 0.4052(2m)         | 0.5108(3m)    | **0.6453**(5m)   | 0.6104(6m)                 | 0.6063(6m)    | 0.7243(37m)       |

## Inferensi

AutoRound secara otomatis memilih backend terbaik yang tersedia berdasarkan pustaka yang terpasang dan meminta pengguna untuk menginstal pustaka tambahan ketika backend yang lebih baik ditemukan.

### CPU

Mendukung 2, 4, dan 8 bit. Kami merekomendasikan penggunaan backend AutoRound Kernel (ARK) untuk inferensi. PyTorch 2.8.0 atau lebih baru diperlukan untuk ARK.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cpu", dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### XPU

Mendukung 2, 4, dan 8 bit. Kami merekomendasikan penggunaan backend AutoRound Kernel (ARK) untuk inferensi. PyTorch 2.8.0 atau lebih baru diperlukan untuk ARK.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="xpu", dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### CUDA

Mendukung 2-8 bit. Kami merekomendasikan penggunaan GPTQModel untuk inferensi 4 dan 8 bit.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cuda", dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### Tentukan Backend Inferensi

AutoRound secara otomatis memilih backend untuk setiap layer berdasarkan kompatibilitas. Secara umum, urutan prioritasnya adalah Marlin > ExLLaMAV2 > Triton, tetapi pilihan akhir bergantung pada faktor-faktor seperti group size, bit width, packing format, perangkat hardware, dan detail implementasi lainnya. Untuk detail lebih lanjut, silakan merujuk ke [backends](https://github.com/intel/auto-round?tab=readme-ov-file#specify-backend),

Backend mungkin tidak selalu menjadi yang paling sesuai untuk perangkat tertentu. Anda dapat menentukan backend yang diinginkan, seperti "ark" untuk CPU dan XPU, atau "marlin/exllamav2/triton" untuk CUDA, sesuai dengan kebutuhan atau kompatibilitas perangkat keras Anda. Harap dicatat bahwa pustaka tambahan yang sesuai mungkin diperlukan.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoRoundConfig

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
quantization_config = AutoRoundConfig(backend="ark")
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cpu", quantization_config=quantization_config, dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### Mengonversi GPTQ/AWQ ke AutoRound

Sebagian besar model GPTQ/AWQ dapat dikonversi ke format AutoRound untuk kompatibilitas dan dukungan yang lebih baik dengan perangkat Intel. Harap diperhatikan bahwa konfigurasi kuantisasi akan berubah jika model tersebut diserialisasi.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoRoundConfig

model_name = "ybelkada/opt-125m-gptq-4bit"
quantization_config = AutoRoundConfig()
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cpu", quantization_config=quantization_config, dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

## Isu

Jika Anda mengalami masalah dengan integrasi transformers, silakan buka masalah di repositori [transformers](https://github.com/huggingface/transformers/issues). Jika Anda mengalami masalah dengan auto-round, silakan buka masalah di repositori [AutoRound](https://github.com/intel/auto-round/issues).

## Pengakuan

Ucapan terima kasih khusus kepada pustaka presisi rendah open-source seperti AutoGPTQ, AutoAWQ, GPTQModel, Triton, Marlin, dan ExLLaMAV2 yang menyediakan kernel CUDA presisi rendah, yang dimanfaatkan dalam AutoRound.

## Kontribusi

Kontribusi untuk [AutoRound](https://github.com/intel/auto-round/pulls) sangat diterima dan dihargai! Baik itu memperbaiki bug, meningkatkan dokumentasi, menambahkan fitur baru, atau mengusulkan perbaikan, bantuan Anda selalu dihargai.