# Quark

[Quark](https://quark.docs.amd.com/latest/) est un kit d’outils de quantification pour l’apprentissage profond, conçu pour être indépendant des types de données, des algorithmes et du matériel spécifiques. Différentes stratégies de prétraitement, algorithmes et types de données peuvent être combinés dans Quark.

La prise en charge de PyTorch intégrée via 🤗 Transformers cible principalement les CPU et GPU AMD, et est destinée avant tout à des fins d'évaluation. Par exemple, il est possible d'utiliser [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) avec le backend 🤗 Transformers pour évaluer de manière transparente une large gamme de modèles quantifiés via Quark.

Les utilisateurs intéressés par Quark peuvent consulter sa [documentation](https://quark.docs.amd.com/latest/) pour commencer à quantifier des modèles et les utiliser dans les bibliothèques open source prises en charge !

Bien que Quark possède son propre format de point de contrôle / [de configuration](https://huggingface.co/amd/Llama-3.1-8B-Instruct-FP8-KV-Quark-test/blob/main/config.json#L26), la bibliothèque prend également en charge la production de modèles avec une disposition de sérialisation compatible avec d'autres implémentations de quantification/temps d'exécution ([AutoAWQ](./awq), [fp8 natif dans 🤗 Transformers](./finegrained_fp8)).

Pour pouvoir charger des modèles quantifiés Quark dans Transformers, il faut d’abord installer la bibliothèque :

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

## Matrice de prise en charge

Les modèles quantifiés via Quark prennent en charge un large éventail de fonctionnalités, qui peuvent être combinées entre elles. Tous les modèles quantifiés, quelle que soit leur configuration, peuvent être rechargés sans accroc via `PretrainedModel.from_pretrained`.

Le tableau ci-dessous présente quelques fonctionnalités prises en charge par Quark :

| **Fonctionnalité**                     | **Sous-ensemble pris en charge dans Quark**                                                                             |   |
|---------------------------------|-----------------------------------------------------------------------------------------------------------|---|
| Types de données                      | int8, int4, int2, bfloat16, float16, fp8_e5m2, fp8_e4m3, fp6_e3m2, fp6_e2m3, fp4, OCP MX, MX6, MX9, bfp16 |   |
| Transformation de pré-quantification | SmoothQuant, QuaRot, SpinQuant, AWQ                                                                       |   |
| Algorithme de quantification          | GPTQ                                                                                                      |   |
| Opérateurs pris en charge             | ``nn.Linear``, ``nn.Conv2d``, ``nn.ConvTranspose2d``, ``nn.Embedding``, ``nn.EmbeddingBag``               |   |
| Granularité                     | par tenseur, par canal, par bloc, par couche, type par couche                                             |   |
| Cache KV                        | fp8                                                                                                       |   |
| Calibration des activations          | MinMax / Percentile / MSE                                                                                 |   |
| Stratégie de quantification           | weight-only, statique, dynamique, avec ou sans quantification de la sortie                                         |   |

## Modèles sur Hugging Face Hub

Les modèles publics utilisant la sérialisation native de Quark sont disponibles à l'adresse https://huggingface.co/models?other=quark.

Bien que Quark prenne également en charge les [modèles utilisant `quant_method="fp8"`](https://huggingface.co/models?other=fp8) et les [modèles utilisant `quant_method="awq"`](https://huggingface.co/models?other=awq), Transformers charge ces modèles plutôt via [AutoAWQ](./awq) ou en utilisant le [support natif de fp8 dans 🤗 Transformers](./finegrained_fp8).

## Utilisation des modèles Quark dans Transformers

Voici un exemple de la manière de charger un modèle Quark dans 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
```