# Quanto

> [!WARNING]
> Le backend Quanto est obsolète et sera supprimé dans la version 1.0.0. Pensez à passer à l'un des autres [backends de quantification](./overview) pris en charge, tels que [bitsandbytes](./bitsandbytes) ou [torchao](./torchao).

[Quanto](https://github.com/huggingface/optimum-quanto) est un backend de quantification PyTorch pour [Optimum](https://huggingface.co/docs/optimum/en/index). Il a été conçu avec une attention particulière portée à la polyvalence et à la simplicité :

- Toutes les fonctionnalités sont disponibles en mode eager (fonctionne avec les modèles non traçables)
- Prend en charge l'entraînement avec quantification
- Les modèles quantifiés sont compatibles avec `torch.compile`
- Les modèles quantifiés sont agnostiques par rapport à l'appareil (par exemple CUDA, XPU, MPS, CPU)

Afin d'utiliser le backend Quanto, vous devez d'abord installer `optimum-quanto>=0.2.6` et `accelerate`

```shell
pip install optimum-quanto accelerate
```

Vous pouvez désormais quantiser un modèle en passant l'objet `QuantoConfig` à la méthode `from_pretrained()`. Bien que la bibliothèque Quanto permette de quantiser les modules `nn.Conv2d` et `nn.LayerNorm`, Diffusers ne prend actuellement en charge que la quantisation des poids des couches `nn.Linear` d'un modèle. L'extrait de code suivant montre comment appliquer la quantisation `float8` avec Quanto.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)

pipe = FluxPipeline.from_pretrained(model_id, transformer=transformer, dtype=dtype)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt, num_inference_steps=50, guidance_scale=4.5, max_sequence_length=512
).images[0]
image.save("output.png")
```

## Passer la quantification sur des modules spécifiques

Il est possible de sauter l'application de la quantification sur certains modules en utilisant l'argument `modules_to_not_convert` dans `QuantoConfig`. Veuillez vous assurer que les modules transmis à cet argument correspondent aux clés des modules dans le `state_dict`

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8", modules_to_not_convert=["proj_out"])
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)
```

## Utilisation de `from_single_file` avec le backend Quanto

`QuantoConfig` est compatible avec `~FromOriginalModelMixin.from_single_file`.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

ckpt_path = "https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/flux1-dev.safetensors"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_single_file(ckpt_path, quantization_config=quantization_config, dtype=torch.bfloat16)
```

## Enregistrer les modèles quantifiés

Diffusers prend en charge la sérialisation des modèles Quanto à l'aide de la méthode `~ModelMixin.save_pretrained`.

Les exigences de sérialisation et de chargement diffèrent entre les modèles quantifiés directement avec la bibliothèque Quanto et les modèles quantifiés avec Diffusers en utilisant Quanto comme backend. Il n'est actuellement pas possible de charger dans Diffusers, à l'aide de `~ModelMixin.from_pretrained`, des modèles quantifiés directement avec Quanto.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)
# save quantized model to reuse
transformer.save_pretrained("<your quantized model save path>")

# you can reload your quantized model with
model = FluxTransformer2DModel.from_pretrained("<your quantized model save path>")
```

## Utiliser `torch.compile` avec Quanto

Actuellement, le backend Quanto prend en charge `torch.compile` pour les types de quantification suivants :

- poids `int8`

```python
import torch
from diffusers import FluxPipeline, FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="int8")
transformer = FluxTransformer2DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    quantization_config=quantization_config,
    dtype=torch.bfloat16,
)
transformer = torch.compile(transformer, mode="max-autotune", fullgraph=True)

pipe = FluxPipeline.from_pretrained(
    model_id, transformer=transformer, dtype=dtype
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"
images = pipe("A cat holding a sign that says hello").images[0]
images.save("flux-quanto-compile.png")
```

## Types de quantification pris en charge

### Poids

- float8
- int8
- int4
- int2