Lora for Diffusers
1.0.0
Ce référentiel fournit le code de tutoriel le plus simple pour que les chercheurs AIGC puissent utiliser LORA en quelques lignes. En utilisant ce manuel, vous pouvez facilement jouer avec n'importe quel modèle LORA à partir de communautés actives telles que HuggingFace et Cititai.
Maintenant, nous soutenons également le contrôlet-pour-diffuseurs, T2i-adapter-for-diffuseurs.
L'adaptation de faible rang des modèles de grandes langues (LORA) est développée par Microsoft pour réduire le nombre de paramètres entraînant en apprenant des paires de matrices de classement-décomposion tout en gelant les poids d'origine. Lora tente de réprimer le "résiduel" du modèle au lieu de l'ensemble du modèle: c'est-à-dire entraîner le
Où
Cette astuce de formation est très utile pour les modèles personnalisés Fune-Tuning sur un grand modèle de base générale. Divers modèles de texte pour image ont été développés construits sur le dessus de la diffusion stable officielle. Maintenant, avec Lora, vous pouvez former efficacement votre propre modèle avec beaucoup moins de ressources.
Safetentenseurs est un nouveau format simple pour stocker les tenseurs en toute sécurité (par opposition à Pickle) libérés en étreignant le visage et c'est toujours rapide (copie zéro). Pour son efficacité, de nombreux modèles de diffusion stables, en particulier les modèles LORA, sont libérés au format SafeTtenseurs. Vous pouvez en trouver plus ses avantages de HuggingFace / Safettensers et l'installer via PIP Installer.
pip install safetensorsDans ce didacticiel, nous montrons pour charger ou insérer LORA pré-formé dans le cadre DIFFUSERS. De nombreux projets intéressants peuvent être trouvés dans HuggingFace et Cititai, mais surtout dans le cadre stable-diffusion-webui, ce qui n'est pas pratique pour les développeurs avancés. Nous avons très motivé par Cloneofsimo / Lora sur le chargement, la fusion et l'interpolation de loras formés. Nous discutons principalement des modèles au format Safetentenseurs qui n'est pas bien compatible avec les diffuseurs.
Un modèle complet comprend tous les modules nécessaires (modèle de base avec ou sans couches LORA), ils sont généralement stockés au format .CKPT ou .Safetenseurs. Nous fournissons deux exemples ci-dessous pour vous montrer comment utiliser à portée de main.
stabilitéi / stable-diffusion-2-1 de Huggingface.
DreamShaper de Civitai.
Vous pouvez télécharger uniquement le fichier .ckpt ou .safetenseurs. Bien que les diffuseurs ne prennent pas en charge les chargements directement, ils fournissent le script de conversion. Téléchargez d'abord les diffuseurs vers local.
git clone https://github.com/huggingface/diffusers cd ./diffusers
# assume you have downloaded xxx.safetensors, it will out save_dir in diffusers format.
python ./scripts/convert_original_stable_diffusion_to_diffusers.py --checkpoint_path xxx.safetensors --dump_path save_dir --from_safetensors
# assume you have downloaded xxx.ckpt, it will out save_dir in diffusers format.
python ./scripts/convert_original_stable_diffusion_to_diffusers.py --checkpoint_path xxx.ckpt --dump_path save_dirEnsuite, vous pouvez charger le modèle
from diffusers import StableDiffusionPipeline
pipeline = StableDiffusionPipeline.from_pretrained(save_dir,torch_dtype=torch.float32)Pour l'instant, les diffuseurs ne peuvent pas supporter des poids de charge dans LORA (généralement au format. Ici, nous montrons nos tentatives dans un style inélégant. Nous fournissons également un exemple.
Notez que la taille du fichier est beaucoup plus petite que le modèle complet, car il ne contient que des poids LORA supplémentaires. Dans le cas, nous devons charger le modèle de base. Il est également très bien de charger le diffusion stable 1.5 comme base, mais pour obtenir des résultats satisfaits, il est recommandé de télécharger le modèle de base suggéré.
Notre méthode est très simple: prendre du poids du .safetensor et fusionner le poids de Lora dans un poids supporté par les diffuseurs. Nous ne convertissons pas. SAFETENSEUR en autre format, nous mettons à jour le poids du modèle de base.
Notre script devrait bien fonctionner avec la plupart des modèles de HuggingFace et Cititai, sinon, vous pouvez également modifier le code par vous-même. Croyez-moi, c'est vraiment simple et vous pouvez le faire.
# the default mergering ratio is 0.75, you can manually set it
python convert_lora_safetensor_to_diffusers.pyNous avons fait un RP pour les diffuseurs sur cette question, où nous déformons davantage la fonction de convertissement afin qu'elle soit plus flexible. Vous pouvez le vérifier directement si vous ne pouvez pas attendre. Il sera bientôt fusionné en diffuseurs!
DIFFUSERS a fourni un train simple_text_to_image_lora.py pour former votre modèle LORA. Veuillez suivre ses instructions pour installer les exigences.
export MODEL_NAME= " CompVis/stable-diffusion-v1-4 "
export DATASET_NAME= " lambdalabs/pokemon-blip-captions "
accelerate launch --mixed_precision= " fp16 " train_text_to_image_lora.py
--pretrained_model_name_or_path= $MODEL_NAME
--dataset_name= $DATASET_NAME --caption_column= " text "
--resolution=512 --random_flip
--train_batch_size=1
--num_train_epochs=100 --checkpointing_steps=5000
--learning_rate=1e-04 --lr_scheduler= " constant " --lr_warmup_steps=0
--seed=42
--output_dir= " sd-pokemon-model-lora "
--validation_prompt= " cute dragon creature " --report_to= " wandb "Une fois que vous avez formé un modèle en utilisant la commande ci-dessus, l'inférence peut être effectuée simplement en utilisant le stablediffusionpipeline après le chargement des poids LORA formés. Vous devez passer le Output_DIR pour charger les poids LORA qui, dans ce cas, est SD-Pokemon-Model-Lora.
import torch
from diffusers import StableDiffusionPipeline
model_path = " your_path/sd-model-finetuned-lora-t4 "
pipe = StableDiffusionPipeline.from_pretrained( " CompVis/stable-diffusion-v1-4 " , torch_dtype=torch.float16)
pipe.unet.load_attn_procs(model_path)
pipe.to( " cuda " )
prompt = " A pokemon with green eyes and red legs. "
image = pipe(prompt, num_inference_steps=30, guidance_scale=7.5).images[0]
image.save( " pokemon.png " )Pour l'instant, les diffuseurs ne soutiennent que Train Lora pour l'UNON. Nous avons soutenu et fait un RP, si vous en avez besoin, veuillez vérifier auprès de notre RP ou ouvrir un problème.
Colossalai soutient déjà Lora. Nous n'avons besoin que de modifier quelques lignes sur le dessus de Train_Dreambooth_Colossalai.py. Cet exemple est pour Dreambooth, mais vous pouvez facilement l'adopter par le texte régulier à la formation d'image. Les poids LORA générés sont uniquement pour les couches d'attention dans l'UNET. Si vous souhaitez également prendre en charge le codeur de texte, veuillez utiliser ACCELETate Framework dans les diffuseurs, car Colossalai ne prend pas encore en charge plusieurs modèles.
from diffusers.loaders import AttnProcsLayers
from diffusers.models.cross_attention import LoRACrossAttnProcessor
# attention here! It is necessaray to init unet under ColoInitContext, not just lora layers
with ColoInitContext(device=get_current_device()):
unet = UNet2DConditionModel.from_pretrained(
args.pretrained_model_name_or_path,
subfolder= " unet " ,
revision=args.revision,
low_cpu_mem_usage=False
)
unet.requires_grad_(False)
# Set correct lora layers
lora_attn_procs = {}
for name in unet.attn_processors.keys ():
cross_attention_dim = None if name.endswith( " attn1.processor " ) else unet.config.cross_attention_dim
if name.startswith( " mid_block " ):
hidden_size = unet.config.block_out_channels[-1]
elif name.startswith( " up_blocks " ):
block_id = int(name[len( " up_blocks. " )])
hidden_size = list(reversed(unet.config.block_out_channels))[block_id]
elif name.startswith( " down_blocks " ):
block_id = int(name[len( " down_blocks. " )])
hidden_size = unet.config.block_out_channels[block_id]
lora_attn_procs[name] = LoRACrossAttnProcessor(
hidden_size=hidden_size, cross_attention_dim=cross_attention_dim
)
unet.set_attn_processor(lora_attn_procs)
lora_layers = AttnProcsLayers(unet.attn_processors)
# DDP
unet = gemini_zero_dpp(unet, args.placement)
# config optimizer for colossalai zero, set initial_scale to large value to avoid underflow
optimizer = GeminiAdamOptimizer(unet,
lr=args.learning_rate,
betas=(args.adam_beta1, args.adam_beta2),
weight_decay=args.adam_weight_decay,
eps=args.adam_epsilon,
initial_scale=2 ** 16,
clipping_norm=args.max_grad_norm)C'est parti, la seule chose est le moyen d'initialisation de l'UNET. Pour économiser des poids Lora uniquement,
torch_unet = get_static_torch_model(unet)
if gpc.get_local_rank(ParallelMode.DATA) == 0:
torch_unet = torch_unet.to(torch.float32)
torch_unet.save_attn_procs(save_path)Ensuite, faites l'inférence
from diffusers import StableDiffusionPipeline
import torch
model_path = " sd-model-finetuned-lora "
pipe = StableDiffusionPipeline.from_pretrained( " CompVis/stable-diffusion-v1-4 " , torch_dtype=torch.float16)
pipe.unet.load_attn_procs(model_path)
pipe.to( " cuda " )
prompt = " A pokemon with green eyes and red legs. "
image = pipe(prompt, num_inference_steps=30, guidance_scale=7.5).images[0]
image.save( " pokemon.png " )Vous pouvez constater que le poids LORA généré n'est que d'environ 3 Mo de taille, c'est due au paramètre par défaut. Pour augmenter la taille, vous pouvez définir manuellement le rang (dimension pour la décomposition de bas rang) pour les couches LORA.
lora_attn_procs[name] = LoRACrossAttnProcessor(hidden_size=hidden_size, cross_attention_dim=cross_attention_dim, rank=128)Ensuite, les poids Lora auront une taille d'environ 100 à 200 Mo. Sachez que les couches LORA sont faciles à surfiance, d'une manière générale, cela devrait être suffisant pour entraîner seulement 100 à 2000 étapes sur de petits ensembles de données (moins de 1k images) avec une taille de lot = 64.
(1) Puis-je ajuster manuellement le poids de Lora lors de la fusion?
Oui, l'alpha ici est le poids de Lora. Nous avons soumis un RP à des diffuseurs où nous fournissons la fonction Warpped flexible.
(2) Puis-je convertir Lora (.Safetenseurs) en d'autres formats soutenus par diffuseurs?
Vous pouvez mais nous ne suggérons pas, voyons ces problèmes. Il existe de nombreuses limites. Par exemple, notre script ne peut pas généraliser à tous les. En outre, le cadre des diffuseurs actuels ne prend en charge que l'ajout de LORA dans les couches d'attention de l'UNE, tandis que de nombreux .Safetenseurs de Civitai contiennent des poids LORA pour d'autres modules comme l'encodeur de texte. Mais LORA pour Encodeur de texte devrait être pris en charge bientôt.
(3) Puis-je mélanger plus d'un modèle LORA?
Oui, la seule chose est de fusionner deux fois. Mais veuillez régler soigneusement l'alpha (poids de Lora), le modèle se dégrade si l'alpha est trop grand.
(4) Quelle est la motivation de ce projet?
Nous constatons qu'il existe de nombreux modèles incroyables dans la plate-forme Civitai, mais la plupart des poids LORA sont au format Safettensers, ce qui n'est pas pratique pour les utilisateurs des diffuseurs. Ainsi, nous écrivons un script de conversion afin que vous puissiez utiliser ces loras dans des diffuseurs. Sachez que nous ne sommes pas cibles pour le diffusion stable-webui, qui est déjà très mature mais a une API totalement différente en tant que diffuseurs.
