LoRA

Ceci est expérimental et l'API peut évoluer à l'avenir.

LoRA (Low-Rank Adaptation of Large Language Models) est une technique d’entraînement populaire et légère qui réduit considérablement le nombre de paramètres entraînables. Elle fonctionne en insérant un plus petit nombre de nouveaux poids dans le modèle, et seuls ceux-ci sont entraînés. Cela rend l’entraînement avec LoRA beaucoup plus rapide, plus efficace en mémoire, et produit des poids de modèle plus petits (quelques centaines de Mo), plus faciles à stocker et à partager. LoRA peut également être combiné avec d’autres techniques d’entraînement comme DreamBooth pour accélérer l’entraînement.

LoRA est très polyvalent et pris en charge pour DreamBooth, Kandinsky 2.2, Stable Diffusion XL et text-to-image.

Ce guide examine le script train_text_to_image_lora.py afin de vous familiariser avec celui-ci et de vous montrer comment l'adapter à votre propre cas d'usage.

Avant d'exécuter le script, assurez-vous d'installer la bibliothèque à partir du code source :

git clone https://github.com/huggingface/diffusers
cd diffusers
pip install .

Accédez au dossier d’exemple contenant le script d’entraînement et installez les dépendances requises pour le script que vous utilisez :

cd examples/text_to_image
pip install -r requirements.txt

🤗 Accelerate est une bibliothèque qui vous aide à entraîner sur plusieurs GPU/TPU ou avec une précision mixte. Elle configure automatiquement votre configuration d’entraînement en fonction de votre matériel et de votre environnement. Consultez le tour rapide de 🤗 Accelerate pour en savoir plus.

Initialiser un environnement 🤗 Accelerate :

accelerate config

Pour configurer un environnement 🤗 Accelerate par défaut sans choisir de configuration :

accelerate config default

Sinon, si votre environnement ne prend pas en charge un shell interactif, comme un notebook, vous pouvez utiliser :

from accelerate.utils import write_basic_config

write_basic_config()

Enfin, si vous souhaitez entraîner un modèle sur votre propre jeu de données, consultez le guide Create a dataset for training pour apprendre à créer un jeu de données compatible avec le script d'entraînement.

Les sections suivantes mettent en évidence les parties du script d’entraînement importantes pour comprendre comment le modifier, mais elles ne couvrent pas tous les aspects du script en détail. Si vous souhaitez en savoir plus, n’hésitez pas à lire le script et à nous faire part de vos questions ou préoccupations.

Paramètres du script

Le script d’entraînement comporte de nombreux paramètres pour vous aider à personnaliser votre session d’entraînement. Tous les paramètres et leurs descriptions se trouvent dans la fonction parse_args(). Des valeurs par défaut sont fournies pour la plupart des paramètres et fonctionnent très bien, mais vous pouvez également définir vos propres valeurs dans la commande d’entraînement si vous le souhaitez.

Par exemple, pour augmenter le nombre d'époches d'entraînement :

accelerate launch train_text_to_image_lora.py \
  --num_train_epochs=150 \

De nombreux paramètres de base et importants sont décrits dans le guide d’entraînement Text-to-image, ce guide se concentre donc uniquement sur les paramètres spécifiques à LoRA :

• --rank : la dimension interne des matrices de faible rang à entraîner ; un rang plus élevé signifie plus de paramètres entraînables
• --learning_rate : le taux d'apprentissage par défaut est 1e-4, mais avec LoRA, vous pouvez utiliser un taux d'apprentissage plus élevé

Script d'entraînement

Le code de prétraitement du jeu de données et la boucle d’entraînement se trouvent dans la fonction main(), et si vous devez adapter le script d’entraînement, c’est ici que vous apporterez vos modifications.

Comme pour les paramètres du script, un parcours détaillé du script d’entraînement est fourni dans le guide d’entraînement Text-to-image. En revanche, ce guide se concentre sur les parties du script relatives à LoRA.

unet_lora_config = LoraConfig(
    r=args.rank,
    lora_alpha=args.rank,
    init_lora_weights="gaussian",
    target_modules=["to_k", "to_q", "to_v", "to_out.0"],
)

unet.add_adapter(unet_lora_config)
lora_layers = filter(lambda p: p.requires_grad, unet.parameters())

text_lora_config = LoraConfig(
    r=args.rank,
    lora_alpha=args.rank,
    init_lora_weights="gaussian",
    target_modules=["q_proj", "k_proj", "v_proj", "out_proj"],
)

text_encoder_one.add_adapter(text_lora_config)
text_encoder_two.add_adapter(text_lora_config)
text_lora_parameters_one = list(filter(lambda p: p.requires_grad, text_encoder_one.parameters()))
text_lora_parameters_two = list(filter(lambda p: p.requires_grad, text_encoder_two.parameters()))

L'optimizer est initialisé avec les lora_layers car ce sont les seuls poids qui seront optimisés :

optimizer = optimizer_cls(
    lora_layers,
    lr=args.learning_rate,
    betas=(args.adam_beta1, args.adam_beta2),
    weight_decay=args.adam_weight_decay,
    eps=args.adam_epsilon,
)

En plus de la configuration des couches LoRA, le script d’entraînement est plus ou moins identique à train_text_to_image.py !

Lancer le script

Une fois que vous avez apporté toutes vos modifications ou que vous êtes satisfait de la configuration par défaut, vous êtes prêt à lancer le script d’entraînement ! 🚀

Entraînons-nous sur le jeu de données Naruto BLIP captions pour générer vos propres personnages de Naruto. Définissez les variables d’environnement MODEL_NAME et DATASET_NAME sur le modèle et le jeu de données respectivement. Vous devez également indiquer où enregistrer le modèle dans OUTPUT_DIR, ainsi que le nom du modèle à enregistrer sur le Hub avec HUB_MODEL_ID. Le script crée et enregistre les fichiers suivants dans votre dépôt :

• points de contrôle des modèles enregistrés
• pytorch_lora_weights.safetensors (les poids LoRA entraînés)

Si vous entraînez sur plus d’un GPU, ajoutez le paramètre --multi_gpu à la commande accelerate launch.

Une session d'entraînement complète prend environ 5 heures sur un GPU 2080 Ti avec 11 Go de VRAM.

export MODEL_NAME="stable-diffusion-v1-5/stable-diffusion-v1-5"
export OUTPUT_DIR="/sddata/finetune/lora/naruto"
export HUB_MODEL_ID="naruto-lora"
export DATASET_NAME="lambdalabs/naruto-blip-captions"

accelerate launch --mixed_precision="fp16"  train_text_to_image_lora.py \
  --pretrained_model_name_or_path=$MODEL_NAME \
  --dataset_name=$DATASET_NAME \
  --dataloader_num_workers=8 \
  --resolution=512 \
  --center_crop \
  --random_flip \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --max_train_steps=15000 \
  --learning_rate=1e-04 \
  --max_grad_norm=1 \
  --lr_scheduler="cosine" \
  --lr_warmup_steps=0 \
  --output_dir=${OUTPUT_DIR} \
  --push_to_hub \
  --hub_model_id=${HUB_MODEL_ID} \
  --report_to=wandb \
  --checkpointing_steps=500 \
  --validation_prompt="A naruto with blue eyes." \
  --seed=1337

Une fois l’entraînement terminé, vous pouvez utiliser votre modèle pour l’inférence :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights("path/to/lora/model", weight_name="pytorch_lora_weights.safetensors")
image = pipeline("A naruto with blue eyes").images[0]

Étapes suivantes

Félicitations pour l'entraînement d'un nouveau modèle avec LoRA ! Pour en savoir plus sur l'utilisation de votre nouveau modèle, les guides suivants peuvent vous être utiles :

• Apprenez à charger différents formats LoRA entraînés à l'aide d'entraîneurs communautaires tels que Kohya et TheLastBen.
• Apprenez à utiliser et à combiner plusieurs LoRA avec PEFT pour l'inférence.