# Quark

[Quark](https://quark.docs.amd.com/latest/) é um toolkit de quantização para deep learning projetado para ser agnóstico em relação a tipos de dados, algoritmos e hardware específicos. Diferentes estratégias de pré-processamento, algoritmos e tipos de dados podem ser combinados no Quark.

O suporte ao PyTorch integrado por meio do 🤗 Transformers tem como principal alvo CPUs e GPUs da AMD e destina-se principalmente a fins de avaliação. Por exemplo, é possível usar o [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) com o backend do 🤗 Transformers e avaliar uma ampla variedade de modelos quantizados por meio do Quark de forma transparente.

Usuários interessados no Quark podem consultar sua [documentação](https://quark.docs.amd.com/latest/) para começar a quantizar modelos e usá-los em bibliotecas open-source compatíveis!

Embora o Quark tenha seu próprio formato de checkpoint / [configuração](https://huggingface.co/amd/Llama-3.1-8B-Instruct-FP8-KV-Quark-test/blob/main/config.json#L26), a biblioteca também suporta a geração de modelos com um layout de serialização compatível com outras implementações de quantização/runtime ([AutoAWQ](./awq), [fp8 nativo no 🤗 Transformers](./finegrained_fp8)).

Para carregar modelos quantizados com Quark no Transformers, é necessário primeiro instalar a biblioteca:

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

## Matriz de suporte

Modelos quantizados por meio do Quark suportam uma ampla gama de recursos, que podem ser combinados. Todos os modelos quantizados, independentemente da sua configuração, podem ser recarregados de forma transparente por meio de `PretrainedModel.from_pretrained`.

A tabela abaixo mostra alguns recursos suportados pelo Quark:

| **Recurso**                     | **Subconjunto suportado no Quark**                                                                             |   |
|---------------------------------|-----------------------------------------------------------------------------------------------------------|---|
| Tipos de dados                      | int8, int4, int2, bfloat16, float16, fp8_e5m2, fp8_e4m3, fp6_e3m2, fp6_e2m3, fp4, OCP MX, MX6, MX9, bfp16 |   |
| Transformação pré-quantização | SmoothQuant, QuaRot, SpinQuant, AWQ                                                                       |   |
| Algoritmo de quantização          | GPTQ                                                                                                      |   |
| Operadores suportados             | ``nn.Linear``, ``nn.Conv2d``, ``nn.ConvTranspose2d``, ``nn.Embedding``, ``nn.EmbeddingBag``               |   |
| Granularidade                     | por tensor, por canal, por bloco, por camada, tipo por camada                                             |   |
| Cache de KV                        | fp8                                                                                                       |   |
| Calibração de ativação          | MinMax / Percentil / MSE                                                                                 |   |
| Estratégia de quantização           | somente pesos, estática, dinâmica, com ou sem quantização de saída                                         |   |

## Modelos no Hugging Face Hub

Modelos públicos que usam a serialização nativa do Quark podem ser encontrados em https://huggingface.co/models?other=quark.

Embora o Quark também suporte [modelos que usam `quant_method="fp8"`](https://huggingface.co/models?other=fp8) e [modelos que usam `quant_method="awq"`](https://huggingface.co/models?other=awq), o Transformers carrega esses modelos mais comumente por meio do [AutoAWQ](./awq) ou utiliza o [suporte nativo a fp8 no 🤗 Transformers](./finegrained_fp8).

## Usando modelos Quark no Transformers

Aqui está um exemplo de como carregar um modelo Quark no 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
```