# HIGGS

[HIGGS](https://huggingface.co/papers/2411.17525) applique une transformation de Hadamard à chaque matrice de poids, puis arrondit des groupes de poids à une grille qui minimise l'erreur quadratique moyenne, sans données de calibration. Utilisez-le pour des poids de 2 à 4 bits sur des GPU NVIDIA, avec les noyaux [FLUTE](https://github.com/HanGuo97/flute) exécutant les produits matriciels.

Le tableau ci-dessous résume ce que HIGGS prend en charge dans Transformers.

| | |
|---|---|
| Configuration | [HiggsConfig](/docs/transformers/v5.24.0/fr/main_classes/quantization#transformers.HiggsConfig) |
| `quant_method` | `higgs` |
| Flux de travail | Quantifier lors du chargement |
| Bits | 2, 3, 4 |
| Matériel | CUDA |
| Enregistrer | ✅ |
| Ajustement fin | ❌ |
| Auto-compilation | ❌ |

## Installer HIGGS

Installez FLUTE 0.3.0 ou une version ultérieure, fast-hadamard-transform et [Accelerate](https://huggingface.co/docs/accelerate/index).

```bash
pip install -U "flute-kernel>=0.3.0" fast_hadamard_transform accelerate
```

## Quantifier un modèle avec HIGGS

Créez un [HiggsConfig](/docs/transformers/v5.24.0/fr/main_classes/quantization#transformers.HiggsConfig) et passez-le à [from_pretrained()](/docs/transformers/v5.24.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained). Définissez `device_map` sur vos appareils CUDA et chargez le modèle en fp16 ou bf16.

```py
from transformers import AutoModelForCausalLM, HiggsConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B",
    quantization_config=HiggsConfig(bits=4),
    device_map="cuda",
)
```

Une fois les poids chargés, FLUTE ajuste ses noyaux pour chaque couche sur votre GPU et réorganise les poids. Les résultats de l’ajustement sont stockés dans `tune_metadata` de la configuration, de sorte qu’un modèle enregistré n’a pas besoin d’être réajusté.

## Configurer HIGGS

Ces paramètres [HiggsConfig](/docs/transformers/v5.24.0/fr/main_classes/quantization#transformers.HiggsConfig) modifient la manière dont les poids sont quantifiés.

| Paramètre | Par défaut | Effet |
|---|---|---|
| `bits` | `4` | Nombre de bits par poids. Prend en charge 2, 3 et 4. |
| `p` | `2` | Dimension de la grille de quantification, soit 1 ou 2. Une grille avec `p=2` arrondit les poids par paires et est plus précise. |
| `group_size` | `256` | Nombre de poids partageant une même échelle. Prend en charge 64, 128 et 256. Doit diviser `hadamard_size`. |
| `hadamard_size` | `512` | Taille de la transformée de Hadamard. La dimension d'entrée de chaque couche est complétée (padding) jusqu'à un multiple de cette taille. Des valeurs plus faibles réduisent la précision. |

## Accélérer l'inférence avec torch.compile

Sans compilation, HIGGS est plus lent que bf16. [generate()](/docs/transformers/v5.24.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate) ne compile pas automatiquement les modèles HIGGS, il faut donc compiler le modèle vous-même avec [torch.compile](../perf_torch_compile).

```py
model = torch.compile(model)
```

Le tableau ci-dessous montre le nombre de passes avant par seconde pour Llama-3.1-8B-Instruct sur une RTX 4090.

| Taille du lot | bf16 (compilé) | HIGGS 4 bits | HIGGS 4 bits (compilé) |
|---|---|---|---|
| 1 | 59 | 41 | 124 |
| 4 | 57 | 42 | 123 |
| 16 | 56 | 41 | 120 |

## Limites

- HIGGS nécessite un GPU CUDA. Le chargement sans GPU CUDA lève une `NotImplementedError`.
- Charger sans `device_map`, ou avec un `device_map` qui inclut `"cpu"` ou `"disk"`, lève une `ValueError`.
- Charger dans un type de données autre que fp16 ou bf16 lève une `ValueError`.

## Ressources

- article [Pousser les limites de la quantification des grands modèles de langage via le théorème de linéarité](https://huggingface.co/papers/2411.17525)
- [FLUTE](https://github.com/HanGuo97/flute) dépôt
- Collection de modèles [HIGGS](https://huggingface.co/collections/ISTA-DASLab/higgs-675308e432fd56b7f6dab94e) d'ISTA-DASLab

