Buckets:
| # 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 | |
Xet Storage Details
- Size:
- 5.4 kB
- Xet hash:
- da3e1500f0bcd57f4f17a46dc951780b0b7a9c7857956a3963f731940b8cde2e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.