Quanto

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

Quanto est un backend de quantification PyTorch pour Optimum. 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

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.

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

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.

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.

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

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

Update on GitHub