Comment exécutez le modèle de flux sur 8 Go GPU RAM? - Analytique Vidhya

Le modèle de flux récemment publié de Black Forest Labs a gagné en popularité pour ses capacités impressionnantes de génération d'images. Cependant, sa taille a initialement empêché son utilisation sur le matériel de consommation standard. Cette limitation a stimulé l'utilisation des services d'API pour éviter le chargement local du modèle. Cependant, le déploiement sur site est resté coûteux en raison des exigences du GPU. Heureusement, la bibliothèque des diffuseurs de Face en câlin prend désormais en charge la quantification via des bits et desBytes, permettant une inférence de flux sur les machines avec seulement 8 Go de RAM GPU.

Objectifs d'apprentissage:

• Configurez les dépendances pour l'utilisation de flux dans un environnement Colab.
• Encoder les invites de texte à l'aide d'un encodeur de texte quantifié à 4 bits pour l'efficacité de la mémoire.
• Implémentez les techniques d'économie de mémoire pour charger et exécuter des modèles de génération d'images en précision mixte.
• Générez des images à partir d'invites de texte à l'aide du pipeline de flux dans Colab.

Cet article fait partie du blogathon des sciences des données.

Table des matières:

• Objectifs d'apprentissage
• Qu'est-ce que le flux?
• Pourquoi la quantification est importante?
  • Quantification avec BitsandBytes
  • Comment fonctionne BitsandBytes?
• Exécution de flux sur le matériel des consommateurs
  • Étape 1: Configuration de l'environnement
  • Étape 2: Gestion de la mémoire GPU
  • Étape 3: Chargement du codeur de texte T5 4 bits
  • Étape 4: Génération des intérêts de texte
  • Étape 5: Chargement du transformateur 4 bits et VAE
  • Étape 6: Génération d'images
• L'avenir de la génération d'images sur les appareils
• Conclusion
  • Principaux à retenir
• Questions fréquemment posées

Qu'est-ce que le flux?

Flux, développé par Black Forest Labs (les créateurs de diffusion stable), représente une progression significative dans les modèles de texte à l'image. Il s'appuie sur une diffusion stable, offrant des performances et une qualité de sortie améliorées. Bien que initialement à forte intensité de ressources, les optimisations permettent une exécution efficace sur le matériel des consommateurs. Cet article montre comment la quantification améliore l'accessibilité de Flux. L'image ci-dessous illustre le compromis entre le potentiel créatif et le coût de calcul.

Flux possède plusieurs composants architecturaux clés:

• Deux codeurs de texte pré-formés (Clip et T5): ces encodeurs améliorent la compréhension rapide du texte et la traduction en images.
• Modèle DIT basé sur le transformateur: Ce squelette de débarras exploite les transformateurs pour l'efficacité et la précision.
• Auto-encodeur variationnel (VAE): Le traitement dans l'espace latent réduit les demandes de calcul tout en maintenant la qualité d'image.

Flux est disponible en plusieurs versions: Flux-Schnell (open-source), Flux-DEV (ouvert, avec une licence plus restrictive) et Flux-Pro (source fermée, API-accessible).

Pourquoi la quantification est importante?

La quantification, une technique pour réduire la taille du modèle en stockant des paramètres en utilisant moins de bits, est cruciale pour exécuter de grands modèles sur du matériel limité. Bien que moins courant dans la génération d'images, il réduit considérablement l'empreinte de la mémoire sans perte de performance substantielle. Les paramètres du réseau neuronal sont généralement stockés en 32 bits, mais la quantification peut réduire cela à 4 bits.

Quantification avec BitsandBytes

La bibliothèque BitsandBytes permet une quantification efficace de K-bit pour Pytorch. Son intégration dans la bibliothèque DIFFUSERS rend le flux en cours d'exécution sur des GPU de 8 Go possible.

Comment fonctionne BitsandBytes?

BitsandBytes quanquent à 8 et 4 bits de précision. La quantification 8 bits gère les valeurs aberrantes différemment pour minimiser la dégradation des performances. La quantification 4 bits comprime en outre le modèle, souvent utilisé avec Qlora pour le réglage fin.

Exécution de flux sur le matériel des consommateurs

Étape 1: Configuration de l'environnement

Assurez-vous un environnement compatible GPU (par exemple, NVIDIA T4 / L4 ou Google Colab). Installez les packages nécessaires:

 ! Pip Installer -uq git https://github.com/huggingface/diffusers@main
! Pip Install -uq git https://github.com/huggingface/transformers@main
! pip install -uq bitsandbytes

Dépendances d'importation:

 Importer des diffuseurs
Transformers d'importation
importer des bitsandbytes comme BNB
à partir des diffuseurs Importer FluxPipeline, FluxTransFormer2dmodel
à partir de transformateurs import t5encodermododel
Importer une torche
Importer GC

Étape 2: Gestion de la mémoire GPU

Définissez une fonction pour effacer la mémoire GPU entre les charges du modèle:

 def flush ():
    GC.Collect ()
    torch.cuda.empty_cache ()
    torch.cuda.reset_max_memory_allocated ()
    torch.cuda.reset_peak_memory_stats ()

flush()

Étape 3: Chargement du codeur de texte T5 4 bits

Chargez le codeur T5 en utilisant la quantification 4 bits:

 CKPT_ID = "Black-Forest-Labs / Flux.1-Dev"
ckpt_4bit_id = "hf-interne-test / flux.1-dev-nf4-pkg"
invite = "Un chien mignon dans la séance photo à Paris"

text_encoder_2_4bit = t5encodermodel.from_pretraind (
    ckpt_4bit_id,
    subfolder = "text_encoder_2",
)

Étape 4: Génération des intérêts de texte

Encoder l'invite à l'aide de l'encodeur quantifié:

 pipeline = fluxpipeline.from_pretraind (
    "Black-Forest-Labs / Flux.1-Dev",
    text_encoder_2 = text_encoder_2_4bit,
    transformateur = aucun,
    vae = aucun,
    torch_dtype = torch.float16,
)

avec torch.no_grad ():
    prompt_emeds, pooled_prompt_embeds, text_ids = pipeline.encode_prompt (
        invite = invite, prompt_2 = aucun, max_sequence_length = 256
    )

pipeline de Del
flush()

Étape 5: Chargement du transformateur 4 bits et VAE

Chargez le transformateur et VAE en mode 4 bits:

 transformateur_4bit = fluxtransformère2dmodel.from_pretrain (ckpt_4bit_id, subfolder = "transformateur")
pipeline = fluxpipeline.from_pretraind (
    ckpt_id,
    text_encoder = aucun,
    text_encoder_2 = aucun,
    tokenizer = aucun,
    tokenizer_2 = aucun,
    transformateur = transformateur_4bit,
    torch_dtype = torch.float16,
)

pipeline.enable_model_cpu_offload ()

Étape 6: Génération d'images

Générer l'image:

 Imprimer ("Running Denoising")
hauteur, largeur = 512, 768
images = pipeline (
    prompt_emeds = prompt_embeds,
    Poild_Prompt_emeds = Poild_Prompt_Embeds,
    num_inference_steps = 50,
    GUIDANCE_SCALE = 5,5,
    hauteur = hauteur,
    largeur = largeur,
    output_type = "pil",
) .Images

images [0] 

L'avenir de la génération d'images sur les appareils

La quantification et la gestion efficace des modèles apportent une IA puissante au matériel des consommateurs, démocratisant l'accès à la génération d'images avancée.

Conclusion

Le flux, combiné à la quantification, permet une génération d'images de haute qualité sur des GPU 8 Go. Cette progression rend l'IA sophistiqué accessible à un public plus large.

Les principaux plats à retenir:

• Le flux fonctionne efficacement dans le colab en utilisant la quantification 4 bits et la précision mixte.
• diffusers et transformers simplifient la génération d'images.
• Une gestion efficace de la mémoire permet une grande exécution de modèles sur des ressources limitées.

Des questions fréquemment posées (identiques à l'original, mais reformatées pour une meilleure lisibilité)

Q1. Objectif de la quantification 4 bits? La quantification 4 bits réduit l'utilisation de la mémoire, permettant à de grands modèles comme le flux de fonctionner efficacement sur des ressources limitées.

Q2. Changer l'invite de texte? Remplacez la variable prompt par la description du texte souhaitée.

Q3. Réglage de la qualité / style de l'image? Ajustez num_inference_steps (Quality) et guidance_scale (adhérence rapide) dans l'appel du pipeline.

Q4. Gestion des erreurs de mémoire dans Colab? Assurer l'utilisation du GPU, la quantification 4 bits et la précision mixte. Envisagez d'abaisser num_inference_steps ou à l'aide du déchargement du processeur.

Q5. Exécuter le script localement? Oui, mais assurez-vous suffisamment de ressources et de mémoire GPU.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!