# Quark

[Quark](https://quark.docs.amd.com/latest/) adalah toolkit kuantisasi deep learning yang dirancang agar tidak bergantung pada tipe data, algoritma, dan perangkat keras tertentu. Berbagai strategi pra-pemrosesan, algoritma, dan tipe data dapat dikombinasikan di Quark.

Dukungan PyTorch yang terintegrasi melalui 🤗 Transformers terutama ditujukan untuk CPU dan GPU AMD, dan utamanya dimaksudkan untuk keperluan evaluasi. Sebagai contoh, Anda dapat menggunakan [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) dengan backend 🤗 Transformers untuk mengevaluasi berbagai model yang dikuantisasi melalui Quark secara mulus.

Pengguna yang tertarik dengan Quark dapat merujuk ke [dokumentasinya](https://quark.docs.amd.com/latest/) untuk mulai melakukan kuantisasi model dan menggunakannya di pustaka open-source yang didukung!

Meskipun Quark memiliki format checkpoint / [konfigurasi](https://huggingface.co/amd/Llama-3.1-8B-Instruct-FP8-KV-Quark-test/blob/main/config.json#L26) miliknya sendiri, pustaka ini juga mendukung pembuatan model dengan tata letak serialisasi yang sesuai dengan implementasi kuantisasi/runtime lainnya ([AutoAWQ](./awq), [fp8 native di 🤗 Transformers](./finegrained_fp8)).

Untuk dapat memuat model terkuantisasi Quark di Transformers, pustaka ini harus diinstal terlebih dahulu:

```bash
pip install amd-quark
```

## Matriks dukungan

Model yang dikuantisasi melalui Quark mendukung berbagai fitur yang dapat dikombinasikan. Semua model terkuantisasi, terlepas dari konfigurasinya, dapat dimuat ulang secara mulus melalui `PretrainedModel.from_pretrained`.

Tabel di bawah ini menunjukkan beberapa fitur yang didukung oleh Quark:

| **Fitur**                     | **Subset yang didukung di Quark**                                                                             |   |
|---------------------------------|-----------------------------------------------------------------------------------------------------------|---|
| Tipe data                      | int8, int4, int2, bfloat16, float16, fp8_e5m2, fp8_e4m3, fp6_e3m2, fp6_e2m3, fp4, OCP MX, MX6, MX9, bfp16 |   |
| Transformasi pra-kuantisasi | SmoothQuant, QuaRot, SpinQuant, AWQ                                                                       |   |
| Algoritma kuantisasi          | GPTQ                                                                                                      |   |
| Operator yang didukung             | ``nn.Linear``, ``nn.Conv2d``, ``nn.ConvTranspose2d``, ``nn.Embedding``, ``nn.EmbeddingBag``               |   |
| Granularitas                     | per-tensor, per-channel, per-block, per-layer, per-layer type                                             |   |
| Cache KV                        | fp8                                                                                                       |   |
| Kalibrasi aktivasi          | MinMax / Persentil / MSE                                                                                 |   |
| Strategi kuantisasi           | weight-only, statis, dinamis, dengan atau tanpa kuantisasi output                                         |   |

## Model di Hugging Face Hub

Model publik yang menggunakan serialisasi native Quark dapat ditemukan di https://huggingface.co/models?other=quark.

Meskipun Quark juga mendukung [model yang menggunakan `quant_method="fp8"`](https://huggingface.co/models?other=fp8) dan [model yang menggunakan `quant_method="awq"`](https://huggingface.co/models?other=awq), Transformers memuat model-model ini lebih melalui [AutoAWQ](./awq) atau menggunakan [dukungan fp8 native di 🤗 Transformers](./finegrained_fp8).

## Menggunakan model Quark di Transformers

Berikut adalah contoh cara memuat model Quark di Transformers:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "EmbeddedLLM/Llama-3.1-8B-Instruct-w_fp8_per_channel_sym"
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

print(model.model.layers[0].self_attn.q_proj)
# QParamsLinear(
#   (weight_quantizer): ScaledRealQuantizer()
#   (input_quantizer): ScaledRealQuantizer()
#   (output_quantizer): ScaledRealQuantizer()
# )

tokenizer = AutoTokenizer.from_pretrained(model_id)
inp = tokenizer("Where is a good place to cycle around Tokyo?", return_tensors="pt")
inp = inp.to(model.device)

res = model.generate(**inp, min_new_tokens=50, max_new_tokens=100)

print(tokenizer.batch_decode(res)[0])
# <|begin_of_text|>Where is a good place to cycle around Tokyo? There are several places in Tokyo that are suitable for cycling, depending on your skill level and interests. Here are a few suggestions:
# 1. Yoyogi Park: This park is a popular spot for cycling and has a wide, flat path that's perfect for beginners. You can also visit the Meiji Shrine, a famous Shinto shrine located in the park.
# 2. Imperial Palace East Garden: This beautiful garden has a large, flat path that's perfect for cycling. You can also visit the
```

