Buckets:
| # Quanto | |
| > [!WARNING] | |
| > El backend Quanto está en desuso y se eliminará en la versión 1.0.0. Considere cambiar a uno de los otros [backends de cuantización](./overview) admitidos, como [bitsandbytes](./bitsandbytes) o [torchao](./torchao). | |
| [Quanto](https://github.com/huggingface/optimum-quanto) es un backend de cuantización de PyTorch para [Optimum](https://huggingface.co/docs/optimum/en/index). Ha sido diseñado con versatilidad y simplicidad en mente: | |
| - Todas las funciones están disponibles en modo eager (funciona con modelos no trazables) | |
| - Admite el entrenamiento consciente de la cuantización | |
| - Los modelos cuantizados son compatibles con `torch.compile` | |
| - Los modelos cuantizados son agnósticos del dispositivo (p. ej., CUDA, XPU, MPS, CPU). | |
| Para usar el backend Quanto, primero debe instalar `optimum-quanto>=0.2.6` y `accelerate` | |
| ```shell | |
| pip install optimum-quanto accelerate | |
| ``` | |
| Ahora puede cuantizar un modelo pasando el objeto `QuantoConfig` al método `from_pretrained()`. Aunque la biblioteca Quanto permite cuantizar los módulos `nn.Conv2d` y `nn.LayerNorm`, actualmente Diffusers solo admite la cuantización de los pesos en las capas `nn.Linear` de un modelo. El siguiente fragmento de código muestra cómo aplicar la cuantización `float8` con 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") | |
| ``` | |
| ## Omitir la cuantización en módulos específicos | |
| Es posible omitir la aplicación de cuantización en ciertos módulos utilizando el argumento `modules_to_not_convert` en `QuantoConfig`. Asegúrese de que los módulos pasados a este argumento coincidan con las claves de los módulos en el `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, | |
| ) | |
| ``` | |
| ## Uso de `from_single_file` con el backend Quanto | |
| `QuantoConfig` es compatible con `~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) | |
| ``` | |
| ## Guardar modelos cuantizados | |
| Diffusers admite la serialización de modelos de Quanto mediante el método `~ModelMixin.save_pretrained`. | |
| Los requisitos de serialización y carga son diferentes para los modelos cuantizados directamente con la librería Quanto y los modelos cuantizados con Diffusers usando Quanto como backend. Actualmente no es posible cargar en Diffusers modelos cuantizados directamente con Quanto usando `~ModelMixin.from_pretrained` | |
| ```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>") | |
| ``` | |
| ## Uso de `torch.compile` con Quanto | |
| Actualmente, el backend de Quanto admite `torch.compile` para los siguientes tipos de cuantización: | |
| - pesos `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") | |
| ``` | |
| ## Tipos de cuantización admitidos | |
| ### Pesos | |
| - float8 | |
| - int8 | |
| - int4 | |
| - int2 | |
Xet Storage Details
- Size:
- 5.16 kB
- Xet hash:
- d3710fd9d75a260434917d9ff19bfd09775a3d6e33d196ce67191fea4f1d24fe
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.