# HQQ

[Half-Quadratic Quantization (HQQ)](https://github.com/mobiusml/hqq/) mendukung kuantisasi cepat secara langsung untuk 8, 4, 3, 2, dan bahkan 1-bit. Metode ini tidak memerlukan data kalibrasi, dan kompatibel dengan modalitas model apa pun (LLM, visi, dll.).

HQQ juga mendukung fine-tuning dengan [PEFT](https://huggingface.co/docs/peft) dan sepenuhnya kompatibel dengan [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) untuk inferensi dan pelatihan yang lebih cepat.

Install HQQ dengan perintah berikut untuk mendapatkan versi terbaru dan membangun kernel CUDA yang sesuai jika Anda menggunakan perangkat cuda. HQQ juga mendukung Intel XPU dengan implementasi pytorch murni.

```bash
pip install hqq
```

Anda dapat memilih untuk mengganti semua lapisan linear dalam model dengan konfigurasi kuantisasi yang sama, atau mengalokasikan konfigurasi kuantisasi tertentu untuk lapisan linear tertentu.

Kuantisasi model dengan membuat [HqqConfig](/docs/transformers/main/id/main_classes/quantization#transformers.HqqConfig) dan menentukan `nbits` serta `group_size` untuk menggantikan semua lapisan linear ([torch.nn.Linear](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html)) pada model.

``` py
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
)
```

Kuantisasi sebuah model dengan membuat kamus yang menentukan `nbits` dan `group_size` untuk lapisan linear yang akan dikuantisasi. Sampaikan nilai-nilai tersebut ke [HqqConfig](/docs/transformers/main/id/main_classes/quantization#transformers.HqqConfig) dan tentukan lapisan mana yang akan dikuantisasi melalui konfigurasi. Pendekatan ini sangat berguna untuk menguantisasi mixture-of-experts (MoE) karena model tersebut kurang terpengaruh oleh pengaturan kuantisasi yang lebih rendah.

``` py
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
)
```

## Backend

HQQ mendukung berbagai backend, termasuk PyTorch murni dan kernel CUDA dequantization kustom. Backend ini cocok untuk GPU lama dan pelatihan PEFT/QLoRA.

```py
from hqq.core.quantize import *

HQQLinear.set_backend(HQQBackend.PYTORCH)
```

Untuk inferensi yang lebih cepat, HQQ mendukung kernel fusi 4-bit (torchao dan Marlin) setelah model dikuantisasi. Kernel ini dapat mencapai hingga 200 token/detik pada satu kartu 4090. Contoh di bawah ini menunjukkan cara mengaktifkan backend torchao_int4.

```py
from hqq.utils.patching import prepare_for_inference

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

Lihat panduan [Backend](https://github.com/mobiusml/hqq/#backend) untuk detail lebih lanjut.

## Sumber daya

Baca artikel blog [Half-Quadratic Quantization of Large Machine Learning Models](https://mobiusml.github.io/hqq_blog/) untuk detail lebih lanjut tentang HQQ.