Currently, LoRA is only supported for the attention layers of the UNet2DConditionalModel
. We also
support LoRA fine-tuning of the text encoder for DreamBooth in a limited capacity. For more details on how we support
LoRA fine-tuning of the text encoder, refer to the discussion on this PR.
Low-Rank Adaptation of Large Language Models (LoRA) is a training method that accelerates the training of large models while consuming less memory. It adds pairs of rank-decomposition weight matrices (called update matrices) to existing weights, and only trains those newly added weights. This has a couple of advantages:
scale
parameter. đĄ LoRA is not only limited to attention layers. The authors found that amending the attention layers of a language model is sufficient to obtain good downstream performance with great efficiency. This is why itâs common to just add the LoRA weights to the attention layers of a model. Check out the Using LoRA for efficient Stable Diffusion fine-tuning blog for more information about how LoRA works!
cloneofsimo was the first to try out LoRA training for Stable Diffusion in the popular lora GitHub repository. 𧨠Diffusers now supports finetuning with LoRA for text-to-image generation and DreamBooth. This guide will show you how to do both.
If youâd like to store or share your model with the community, login to your Hugging Face account (create one if you donât have one already):
huggingface-cli login
Finetuning a model like Stable Diffusion, which has billions of parameters, can be slow and difficult. With LoRA, it is much easier and faster to finetune a diffusion model. It can run on hardware with as little as 11GB of GPU RAM without resorting to tricks such as 8-bit optimizers.
Letâs finetune stable-diffusion-v1-5
on the PokĂŠmon BLIP captions dataset to generate your own PokĂŠmon.
Specify the MODEL_NAME
environment variable (either a Hub model repository id or a path to the directory containing the model weights) and pass it to the ~diffusers.DiffusionPipeline.from_pretrained.pretrained_model_name_or_path
argument. Youâll also need to set the DATASET_NAME
environment variable to the name of the dataset you want to train on.
The OUTPUT_DIR
and HUB_MODEL_ID
variables are optional and specify where to save the model to on the Hub:
export MODEL_NAME="runwayml/stable-diffusion-v1-5"
export OUTPUT_DIR="/sddata/finetune/lora/pokemon"
export HUB_MODEL_ID="pokemon-lora"
export DATASET_NAME="lambdalabs/pokemon-blip-captions"
There are some flags to be aware of before you start training:
--push_to_hub
stores the trained LoRA embeddings on the Hub.--report_to=wandb
reports and logs the training results to your Weights & Biases dashboard (as an example, take a look at this report).--learning_rate=1e-04
, you can afford to use a higher learning rate than you normally would with LoRA.Now youâre ready to launch the training (you can find the full training script here):
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 pokemon with blue eyes." \
--seed=1337
Now you can use the model for inference by loading the base model in the StableDiffusionPipeline and then the DPMSolverMultistepScheduler:
>>> import torch
>>> from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
>>> model_base = "runwayml/stable-diffusion-v1-5"
>>> pipe = StableDiffusionPipeline.from_pretrained(model_base, torch_dtype=torch.float16)
>>> pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
Load the LoRA weights from your finetuned model on top of the base model weights, and then move the pipeline to a GPU for faster inference. When you merge the LoRA weights with the frozen pretrained model weights, you can optionally adjust how much of the weights to merge with the scale
parameter:
đĄ A scale
value of 0
is the same as not using your LoRA weights and youâre only using the base model weights, and a scale
value of 1
means youâre only using the fully finetuned LoRA weights. Values between 0
and 1
interpolates between the two weights.
>>> pipe.unet.load_attn_procs(lora_model_path)
>>> pipe.to("cuda")
# use half the weights from the LoRA finetuned model and half the weights from the base model
>>> image = pipe(
... "A pokemon with blue eyes.", num_inference_steps=25, guidance_scale=7.5, cross_attention_kwargs={"scale": 0.5}
... ).images[0]
# use the weights from the fully finetuned LoRA model
>>> image = pipe("A pokemon with blue eyes.", num_inference_steps=25, guidance_scale=7.5).images[0]
>>> image.save("blue_pokemon.png")
If you are loading the LoRA parameters from the Hub and if the Hub repository has
a base_model
tag (such as this), then
you can do:
from huggingface_hub.repocard import RepoCard
lora_model_id = "sayakpaul/sd-model-finetuned-lora-t4"
card = RepoCard.load(lora_model_id)
base_model_id = card.data.to_dict()["base_model"]
pipe = StableDiffusionPipeline.from_pretrained(base_model_id, torch_dtype=torch.float16)
...
DreamBooth is a finetuning technique for personalizing a text-to-image model like Stable Diffusion to generate photorealistic images of a subject in different contexts, given a few images of the subject. However, DreamBooth is very sensitive to hyperparameters and it is easy to overfit. Some important hyperparameters to consider include those that affect the training time (learning rate, number of training steps), and inference time (number of steps, scheduler type).
đĄ Take a look at the Training Stable Diffusion with DreamBooth using 𧨠Diffusers blog for an in-depth analysis of DreamBooth experiments and recommended settings.
Letâs finetune stable-diffusion-v1-5
with DreamBooth and LoRA with some đś dog images. Download and save these images to a directory.
To start, specify the MODEL_NAME
environment variable (either a Hub model repository id or a path to the directory containing the model weights) and pass it to the ~diffusers.DiffusionPipeline.from_pretrained.pretrained_model_name_or_path
argument. Youâll also need to set INSTANCE_DIR
to the path of the directory containing the images.
The OUTPUT_DIR
variables is optional and specifies where to save the model to on the Hub:
export MODEL_NAME="runwayml/stable-diffusion-v1-5"
export INSTANCE_DIR="path-to-instance-images"
export OUTPUT_DIR="path-to-save-model"
There are some flags to be aware of before you start training:
--push_to_hub
stores the trained LoRA embeddings on the Hub.--report_to=wandb
reports and logs the training results to your Weights & Biases dashboard (as an example, take a look at this report).--learning_rate=1e-04
, you can afford to use a higher learning rate than you normally would with LoRA.Now youâre ready to launch the training (you can find the full training script here):
accelerate launch train_dreambooth_lora.py \
--pretrained_model_name_or_path=$MODEL_NAME \
--instance_data_dir=$INSTANCE_DIR \
--output_dir=$OUTPUT_DIR \
--instance_prompt="a photo of sks dog" \
--resolution=512 \
--train_batch_size=1 \
--gradient_accumulation_steps=1 \
--checkpointing_steps=100 \
--learning_rate=1e-4 \
--report_to="wandb" \
--lr_scheduler="constant" \
--lr_warmup_steps=0 \
--max_train_steps=500 \
--validation_prompt="A photo of sks dog in a bucket" \
--validation_epochs=50 \
--seed="0" \
--push_to_hub
Itâs also possible to additionally fine-tune the text encoder with LoRA. This, in most cases, leads
to better results with a slight increase in the compute. To allow fine-tuning the text encoder with LoRA,
specify the --train_text_encoder
while launching the train_dreambooth_lora.py
script.
Now you can use the model for inference by loading the base model in the StableDiffusionPipeline:
>>> import torch
>>> from diffusers import StableDiffusionPipeline
>>> model_base = "runwayml/stable-diffusion-v1-5"
>>> pipe = StableDiffusionPipeline.from_pretrained(model_base, torch_dtype=torch.float16)
Load the LoRA weights from your finetuned DreamBooth model on top of the base model weights, and then move the pipeline to a GPU for faster inference. When you merge the LoRA weights with the frozen pretrained model weights, you can optionally adjust how much of the weights to merge with the scale
parameter:
đĄ A scale
value of 0
is the same as not using your LoRA weights and youâre only using the base model weights, and a scale
value of 1
means youâre only using the fully finetuned LoRA weights. Values between 0
and 1
interpolates between the two weights.
>>> pipe.unet.load_attn_procs(lora_model_path)
>>> pipe.to("cuda")
# use half the weights from the LoRA finetuned model and half the weights from the base model
>>> image = pipe(
... "A picture of a sks dog in a bucket.",
... num_inference_steps=25,
... guidance_scale=7.5,
... cross_attention_kwargs={"scale": 0.5},
... ).images[0]
# use the weights from the fully finetuned LoRA model
>>> image = pipe("A picture of a sks dog in a bucket.", num_inference_steps=25, guidance_scale=7.5).images[0]
>>> image.save("bucket-dog.png")
Note that the use of LoraLoaderMixin.load_lora_weights
is preferred to UNet2DConditionLoadersMixin.load_attn_procs
for loading LoRA parameters. This is because
LoraLoaderMixin.load_lora_weights
can handle the following situations:
LoRA parameters that donât have separate identifiers for the UNet and the text encoder (such as "patrickvonplaten/lora_dreambooth_dog_example"
). So, you can just do:
pipe.load_lora_weights(lora_model_path)
LoRA parameters that have separate identifiers for the UNet and the text encoder such as: "sayakpaul/dreambooth"
.