Exécuter FLUX.1-dev GGUF Q8 en Python

Accélérer FLUX.1-dev avec la quantification GGUF

Sommaire

FLUX.1-dev est un modèle puissant de génération d’images à partir de texte qui produit des résultats impressionnants, mais sa demande en mémoire de 24 Go ou plus le rend difficile à exécuter sur de nombreux systèmes. Quantification GGUF de FLUX.1-dev offre une solution, réduisant l’utilisation de la mémoire d’environ 50 % tout en maintenant une excellente qualité d’image.

exemple de sortie Q8 quantifiée FLUX.1-dev - asic Cette image a été générée à l’aide du modèle FLUX.1-dev quantifié Q8 au format GGUF, démontrant que la qualité est préservée même avec une empreinte mémoire réduite.

Qu’est-ce que la quantification GGUF ?

GGUF (GPT-Generated Unified Format) est un format de quantification initialement développé pour les modèles de langage, mais désormais pris en charge pour les modèles de diffusion comme FLUX. La quantification réduit la taille du modèle en stockant les poids dans des formats de précision plus faible (8 bits, 6 bits ou 4 bits) au lieu de la précision complète de 16 bits ou 32 bits.

Pour FLUX.1-dev, la composante transformer (la partie la plus grande du modèle) peut être quantifiée, réduisant ainsi son empreinte mémoire de 24 Go à environ 12 Go avec la quantification Q8_0, ou même plus bas avec des niveaux de quantification plus agressifs.

Avantages de la quantification GGUF

Les principaux avantages de l’utilisation des modèles FLUX quantifiés GGUF incluent :

  • Réduction de l’utilisation de la mémoire : Réduire les exigences en VRAM de moitié, rendant FLUX.1-dev accessible sur plus de matériel
  • Qualité maintenue : La quantification Q8_0 préserve la qualité des images avec des différences visibles minimales
  • Chargement plus rapide : Les modèles quantifiés se chargent plus rapidement en raison de leur taille de fichier plus petite
  • Consommation d’énergie plus faible : Une utilisation de la mémoire réduite se traduit par une consommation d’énergie plus faible pendant l’inférence

Dans nos tests, le modèle quantifié utilise environ 12 à 15 Go de VRAM par rapport à 24 Go ou plus pour le modèle complet, tandis que le temps de génération reste similaire.

Installation et configuration

Pour utiliser FLUX.1-dev quantifié GGUF, vous aurez besoin du package gguf en plus des dépendances standard diffusers. Si vous utilisez déjà FLUX pour la génération d’images à partir de texte, vous connaissez déjà la configuration de base.

Si vous utilisez uv comme gestionnaire de packages Python, vous pouvez installer les packages requis avec :

uv pip install -U diffusers torch transformers gguf

Ou avec pip standard :

pip install -U diffusers torch transformers gguf

Implémentation

La différence clé lors de l’utilisation de modèles GGUF quantifiés est que vous chargez le transformer séparément à l’aide de FluxTransformer2DModel.from_single_file() avec GGUFQuantizationConfig, puis vous le transmettez à la pipeline. Si vous avez besoin d’une référence rapide pour la syntaxe Python, consultez le cheat sheet Python. Voici un exemple complet fonctionnel :

import os
import torch
from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig

# Chemins
gguf_model_path = "/chemin/vers/flux1-dev-Q8_0.gguf"
base_model_path = "/chemin/vers/FLUX.1-dev-config"  # Seulement les fichiers de configuration

# Charger le transformer quantifié GGUF
print(f"Chargement du transformer quantifié GGUF depuis : {gguf_model_path}")
transformer = FluxTransformer2DModel.from_single_file(
    gguf_model_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    config=base_model_path,
    subfolder="transformer",
    torch_dtype=torch.bfloat16,
)

# Créer la pipeline avec le transformer quantifié
print(f"Création de la pipeline avec le modèle de base : {base_model_path}")
pipe = FluxPipeline.from_pretrained(
    base_model_path,
    transformer=transformer,
    torch_dtype=torch.bfloat16,
)

# Activer le déchargement vers le CPU (nécessaire pour GGUF)
pipe.enable_model_cpu_offload()
# Note : enable_sequential_cpu_offload() n'est pas compatible avec GGUF

# Générer une image
prompt = "Un paysage urbain futuriste au coucher du soleil avec des lumières néon"
image = pipe(
    prompt,
    height=496,
    width=680,
    guidance_scale=3.5,
    num_inference_steps=60,
    max_sequence_length=512,
    generator=torch.Generator("cpu").manual_seed(42)
).images[0]

image.save("output.jpg")

Considérations importantes

Fichiers de configuration du modèle

Lors de l’utilisation de la quantification GGUF, vous avez toujours besoin des fichiers de configuration du modèle original FLUX.1-dev. Cela inclut :

  • model_index.json - Structure de la pipeline
  • Configurations des composants (transformer, text_encoder, text_encoder_2, vae, scheduler)
  • Fichiers du tokenizer
  • Poids du text_encoder et du VAE (ces derniers ne sont pas quantifiés)

Les poids du transformer proviennent du fichier GGUF, mais tous les autres composants nécessitent les fichiers du modèle original.

Compatibilité du déchargement vers le CPU

Important : enable_sequential_cpu_offload() n’est pas compatible avec les modèles quantifiés GGUF et provoquera une erreur KeyError: None. Je n’utilise que enable_model_cpu_offload() lors de l’utilisation de transformers quantifiés.

Niveaux de quantification

Les niveaux de quantification disponibles pour FLUX.1-dev incluent :

  • Q8_0 : Qualité optimale, ~14-15 Go de mémoire (recommandé)
  • Q6_K : Bon équilibre, ~12 Go de mémoire
  • Q4_K : Compression maximale, ~8 Go de mémoire (je suppose qu’elle affecte la qualité de manière non favorable)

Pour la plupart des cas d’utilisation, la quantification Q8_0 offre le meilleur équilibre entre économie de mémoire et qualité d’image.

Comparaison des performances

Dans nos tests avec des prompts et des paramètres identiques :

Modèle Utilisation de la VRAM Temps de génération Qualité
FLUX.1-dev complet 24 Go Je n’ai pas de GPU aussi grand Excellente (je pense)
FLUX.1-dev complet ~3 Go avec enable_sequential_cpu_offload() ~329s Excellente
GGUF Q8_0 ~14-15 Go ~98s !!! Excellente
GGUF Q6_K ~10-12 Go ~116s Très bonne

Le modèle quantifié, car il nécessite maintenant moins de déchargement vers le CPU, a une vitesse de génération plus de trois fois plus rapide tout en utilisant significativement moins de mémoire, ce qui le rend pratique pour les systèmes avec une VRAM limitée.

J’ai testé les deux modèles avec le prompt suivant :

Un plan rapproché futuriste d'une puce d'inference de transformer avec des circuits complexes, une lumière bleue émise par des unités de multiplication matricielle denses et des ALUs à faible précision, entourée de tampons SRAM sur puce et de pipelines de quantification, rendue en style photoréalistique hyper-détallé avec un éclairage froid et clinique.

La sortie d’exemple de FLUX.1-dev Q8 est l’image de couverture de ce post - voir ci-dessus.

La sortie d’exemple de FLUX.1-dev non quantifié est ci-dessous :

exemple d’image produite par FLUX.1-dev non quantifié - asic

Je ne vois pas beaucoup de différence en termes de qualité.

Conclusion

La quantification GGUF rend FLUX.1-dev accessible à un plus large éventail de matériel tout en maintenant la haute qualité de génération d’images pour laquelle le modèle est connu. En réduisant les exigences en mémoire d’environ 50 %, vous pouvez exécuter la génération d’images à partir de texte d’avant-garde sur un matériel plus abordable sans perte significative de qualité.

L’implémentation est simple avec la bibliothèque diffusers, nécessitant uniquement de légères modifications à la configuration standard de la pipeline FLUX. Pour la plupart des utilisateurs, la quantification Q8_0 offre l’équilibre optimal entre efficacité mémoire et qualité d’image.

Si vous travaillez avec FLUX.1-Kontext-dev pour l’amélioration d’images, des techniques de quantification similaires pourraient devenir disponibles à l’avenir.

Articles liés

Références