# GGUF

Le format de fichier GGUF est généralement utilisé pour stocker des modèles destinés à l'inférence avec [GGML](https://github.com/ggerganov/ggml) et prend en charge diverses options de quantification par bloc. Diffusers permet de charger des points de contrôle pré-quantifiés et enregistrés au format GGUF via le chargement `from_single_file` avec les classes de modèle. Le chargement de points de contrôle GGUF via les Pipelines n'est actuellement pas pris en charge.

L'exemple suivant charge le modèle transformer [FLUX.1 DEV](https://huggingface.co/black-forest-labs/FLUX.1-dev) en utilisant la variante de quantification GGUF Q2_K.

Avant de commencer, veuillez installer gguf dans votre environnement

```shell
pip install -U gguf
```

Étant donné que GGUF est un format de fichier unique, utilisez `~FromSingleFileMixin.from_single_file` pour charger le modèle et passez-y [GGUFQuantizationConfig](/docs/diffusers/main/fr/api/quantization#diffusers.GGUFQuantizationConfig).

Lors de l’utilisation de points de contrôle GGUF, les poids quantifiés restent dans un `dtype` à faible mémoire (généralement `torch.uint8`) et sont déquantifiés dynamiquement puis convertis dans le `compute_dtype` configuré lors du passage avant de chaque module à travers le modèle. Le `GGUFQuantizationConfig` vous permet de définir le `compute_dtype`.

Les fonctions utilisées pour la déquantisation dynamique sont basées sur le travail remarquable de [city96](https://github.com/city96/ComfyUI-GGUF), qui a créé les ports Pytorch de l'implémentation [`numpy`](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/gguf/quants.py) originale de [compilade](https://github.com/compilade).

```python
import torch

from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig

ckpt_path = (
    "https://huggingface.co/city96/FLUX.1-dev-gguf/blob/main/flux1-dev-Q2_K.gguf"
)
transformer = FluxTransformer2DModel.from_single_file(
    ckpt_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    dtype=torch.bfloat16,
)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    transformer=transformer,
    dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(prompt, generator=torch.manual_seed(0)).images[0]
image.save("flux-gguf.png")
```

## Utilisation de noyaux CUDA optimisés avec GGUF

Les noyaux CUDA optimisés peuvent accélérer l’inférence des modèles quantifiés GGUF d’environ 10 %. Cette fonctionnalité nécessite un GPU compatible avec `torch.cuda.get_device_capability` supérieur à 7 et la bibliothèque de noyaux :

```shell
pip install -U kernels
```

Une fois installé, définissez `DIFFUSERS_GGUF_CUDA_KERNELS=true` pour utiliser des noyaux optimisés lorsque ceux-ci sont disponibles. Notez que les noyaux CUDA peuvent introduire de légères différences numériques par rapport à l’implémentation GGUF originale, ce qui peut entraîner des variations visuelles subtiles dans les images générées. Pour désactiver l’utilisation des noyaux CUDA, définissez la variable d’environnement `DIFFUSERS_GGUF_CUDA_KERNELS=false`.

Les noyaux GGUF sont téléchargés depuis le dépôt [`Isotr0py/ggml`](https://huggingface.co/Isotr0py/ggml), dont l’éditeur n’est pas un éditeur de noyaux approuvé sur le Hub. Son chargement télécharge et exécute du code depuis le Hub, Diffusers exige donc que vous activiez explicitement cette option en définissant `DIFFUSERS_TRUST_REMOTE_KERNELS=true`. Consultez [Faire confiance aux noyaux distants](../optimization/attention_backends#trusting-remote-kernels) pour plus de détails.

## Types de quantification pris en charge

- BF16
- Q4_0
- Q4_1
- Q5_0
- Q5_1
- Q8_0
- Q2_K
- Q3_K
- Q4_K
- Q5_K
- Q6_K

## Convertir en GGUF

Utilisez l'Espace ci-dessous pour convertir un point de contrôle Diffusers au format GGUF pour l'inférence. Lancer la conversion :

<iframe src="https://diffusers-internal-dev-diffusers-to-gguf.hf.space" frameborder="0" width="850" height="450"
>

```py
import torch

from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig

ckpt_path = (
    "https://huggingface.co/sayakpaul/different-lora-from-civitai/blob/main/flux_dev_diffusers-q4_0.gguf"
)
transformer = FluxTransformer2DModel.from_single_file(
    ckpt_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    config="black-forest-labs/FLUX.1-dev",
    subfolder="transformer",
    dtype=torch.bfloat16,
)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    transformer=transformer,
    dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(prompt, generator=torch.manual_seed(0)).images[0]
image.save("flux-gguf.png")
```

Lors de l'utilisation de points de contrôle GGUF au format Diffusers, il est obligatoire de fournir le chemin du `config` du modèle. Si la configuration du modèle se trouve dans un `subfolder`, il faut également le spécifier.