Lora for Diffusers
1.0.0
Este repositorio proporciona el código tutorial más simple para que los investigadores de AIGC usen Lora en solo unas pocas líneas. Usando este manual, puede jugar fácilmente con cualquier modelo de Lora de comunidades activas como Huggingface y Cititai.
Ahora, también admitimos Controlnet-for-Diffusers, T2I-Adapter-For-Diffusers.
Microsoft desarrolla la adaptación de bajo rango de modelos de idiomas grandes (Lora) para reducir el número de parámetros entrenables aprendiendo pares de matrices de descomposición de rango mientras congelan los pesos originales. Lora intenta ajustar el "residual" del modelo en lugar de todo el modelo: es decir, entrenar el
Dónde
Este truco de entrenamiento es bastante útil para ajustar los modelos personalizados de FUNE en un modelo base general grande. Se han desarrollado varios modelos de texto a imagen construido en la parte superior de la difusión estable oficial. Ahora, con Lora, puede capacitar de manera eficiente su propio modelo con mucho menos recursos.
Safetensors es un nuevo formato simple para almacenar tensores de manera segura (a diferencia del pepinillo) liberado por abrazar la cara y eso aún es rápido (copia cero). Para su eficiencia, muchos modelos de difusión estables, especialmente los modelos Lora se lanzan en formato Safetensors. Puede encontrar más sus ventajas de Huggingface/Safetensors e instalarlo a través de PIP Install.
pip install safetensorsEn este tutorial, mostramos cargar o insertar Lora pre-entrenado en el marco de difusores. Se pueden encontrar muchos proyectos interesantes en Huggingface y Cititai, pero principalmente en el marco de Difusión Estable-Webui, que no es conveniente para los desarrolladores avanzados. Estamos muy motivados por Clonofsimo/Lora sobre la carga, la fusión e interpolación de loras entrenadas. Discutimos principalmente modelos en formato Safetensors que no es bien compatible con los difusores.
Un modelo completo incluye todos los módulos necesarios (modelo base con o sin capas lora), generalmente se almacenan en formato .ckpt o .safetensores. Proporcionamos dos ejemplos a continuación para mostrarle cómo usar a mano.
estabilidadi/estable-difusión-2-1 de Huggingface.
Dreamshaper de Civitai.
Puede descargar el archivo .ckpt o .safetensors solamente. Aunque los difusores no admiten cargarlos directamente, sí proporcionan el script de conversión. Primero descargue difusores al 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_dirEntonces, puedes cargar el modelo
from diffusers import StableDiffusionPipeline
pipeline = StableDiffusionPipeline.from_pretrained(save_dir,torch_dtype=torch.float32)Por ahora, los difusores no pueden soportar los pesos de carga en Lora (generalmente en formato. Safetensor). Aquí mostramos nuestros intentos en un estilo inelegador. También proporcionamos un ejemplo.
Tenga en cuenta que el tamaño del archivo es mucho más pequeño que el modelo completo, ya que solo contiene pesos adicionales de Lora. En el caso, tenemos que cargar el modelo base. También está bien cargar la difusión estable 1.5 como base, pero para obtener resultados satisfechos, se recomienda descargar el modelo base sugerido.
Nuestro método es muy sencillo: elimine el peso de .Safetensor y fusione el peso de Lora en un peso de los difusores soportados. No convertimos .Safetensor en otro formato, actualizamos el peso del modelo base.
Nuestro script debería funcionar bien con la mayoría de los modelos de Huggingface y Cititai, si no, también puede modificar el código por su cuenta. Créeme, es realmente simple y puedes hacerlo.
# the default mergering ratio is 0.75, you can manually set it
python convert_lora_safetensor_to_diffusers.pyHemos hecho un PR para los difusores sobre este tema, donde deformamos aún más la función de converción para que sea más flexible. Puede verificarlo directamente si no puede esperar. ¡Pronto se fusionará en difusores!
Diffusers ha proporcionado un simple Train_Text_TO_Image_Lora.py para entrenar su modelo Lora. Siga su instrucción para instalar los requisitos.
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 "Una vez que haya entrenado un modelo utilizando el comando anterior, la inferencia se puede hacer simplemente utilizando el stablediffusionPipeline después de cargar los pesos de Lora entrenados. Debe pasar el output_dir para cargar los pesos Lora que, en este caso, es 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 " )Por ahora, los difusores solo admiten Train Lora para Unet. Hemos admitido y hecho un PR, si lo necesita, consulte con nuestro PR o abra un problema.
Colossalai ya apoya a Lora. Solo necesitamos modificar algunas líneas en la parte superior de Train_DreamBooth_Colossalai.py. Este ejemplo es para Dreambooth, pero puede adoptar fácilmente su texto regular para el entrenamiento de imágenes. Los pesos de lora generados son solo para capas de atención en el unlo. Si también desea admitir el codificador de texto, use el marco Acceletate en difusores, ya que Colossalai aún no admite múltiples modelos.
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)Aquí vamos, lo único es la forma de inicialización del unlo. Para ahorrar pesas lora solamente,
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)Entonces, haz inferencia
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 " )Puede encontrar que el peso de Lora generado es de solo un tamaño de 3 MB, esto se debe a la configuración predeterminada. Para aumentar el tamaño, puede establecer manualmente el rango (dimensión para la descomposición de bajo rango) para las capas de Lora.
lora_attn_procs[name] = LoRACrossAttnProcessor(hidden_size=hidden_size, cross_attention_dim=cross_attention_dim, rank=128)Luego, los pesos de Lora tendrán un tamaño de aproximadamente 100-200 MB. Tenga en cuenta que las capas de Lora son fáciles de superar, en general, debería ser suficiente para entrenar solo 100 - 2000 pasos en pequeños conjuntos de datos (menos de 1k imágenes) con tamaño por lotes = 64.
(1) ¿Puedo ajustar manualmente el peso de Lora al fusionar?
Sí, el alfa aquí es el peso para Lora. Hemos presentado un PR a difusores donde proporcionamos la función WARPPED flexible.
(2) ¿Puedo solo convertir lora (.safetensores) en otros formatos que los difusores apoyaron?
Puedes pero no sugerimos, ver estos problemas. Hay muchas limitaciones. Por ejemplo, nuestro script no puede generalizar a todos los safetensores porque algunos de ellos tienen diferentes nombres. Además, el marco de difusores de corriente solo admite agregar a Lora a las capas de atención del Unet, mientras que muchos. Los seguidores de Civitai contienen pesos de Lora para otros módulos como el codificador de texto. Pero Lora para el codificador de texto debe ser compatible pronto.
(3) ¿Puedo mezclar más de un modelo Lora?
Sí, lo único es fusionarse dos veces. Pero, por favor, establezca cuidadosamente el alfa (peso de Lora), el modelo se degrada si el alfa es demasiado grande.
(4) ¿Cuál es la motivación de este proyecto?
Encontramos que hay muchos modelos increíbles en la plataforma Civitai, pero la mayoría de los pesos de Lora están en formato Safetensors, que no es conveniente para los usuarios de difusores. Por lo tanto, escribimos un script de conversión para que pueda usar estas loras en difusores. Tenga en cuenta que no somos objetivo para la difusión estable-webui, que ya es muy madura, pero tiene una API totalmente diferente como difusores.
