Stable LoRA

Establo lora (wip)

Entrene a Lora utilizando la implementación oficial de Microsoft con modelos de difusión estable. Esta es la forma más eficiente y fácil de entrenar a LORAS sin la complejidad adicional al tiempo que se puede compartir entre bibliotecas e implementaciones.

? Este repositorio todavía está en desarrollo activo. Espere errores hasta que se elimine el indicador de WIP . ?

Empezando

Clonar este repositorio en su carpeta de entrenamiento:

git clone https://github.com/ExponentialML/Stable-LoRA

Instalar requisitos de este repositorio:

pip install -r requirements.txt

Ejemplo

La capacitación se realiza utilizando la biblioteca de difusores.

Vea el ejemplo_train_script.sh para un script de ejemplo de DreamBooth.

Ejecutarlo es tan fácil como hacer:

 accelerate launch train_lora . py 
  - - pretrained_model_name_or_path = "runwayml/stable-diffusion-v1-5" 
  - - instance_data_dir = "instance_images" 
  - - lora_rank = 64 
  - - output_dir = "./output" 
  - - instance_prompt = "a shld dog" 
  - - resolution = 512 
  - - mixed_precision = "fp16" 
  - - train_text_encoder 
  - - learning_rate = 1e-4 
  - - resize = True 
  - - save_steps = 200 
  - - preview_steps = 100 
  - - lr_scheduler = "constant_with_warmup" 
  - - lr_warmup_steps = 50 
  - - max_train_steps = 5000 
  - - save_preview 
  - - preview_prompt = "a shld dog as a super hero"

Después del entrenamiento, los resultados se guardarán en su carpeta de salida.

De manera predeterminada, se guarda una variante WebUI automática11111111 junto con ellos (la extensión de WebUI está en desarrollo).

Desarrolladores

Simplemente agréguelo a su modelo antes del bucle de entrenamiento.

 # Import function to add the LoRA, as well as target modules.
from stable_lora . lora import add_lora_to , UNET_REPLACE , TEXT_ENCODER_REPLACE

from diffusers import StableDiffusionPipeline

# Load a Stable Diffusion Model
pipeline = StableDiffusionPipeline . from_pretrained ( pretrained_model_name_or_path )

# Freeze the models. Remember, only the LoRA weights get trained, not the model itself.
pipeline . unet . requires_grad_ ( False )
pipeline . text_encoder . requires_grad_ ( False )

# Add LoRA to the UNET
add_lora_to (
    pipeline . unet , 
    target_module = UNET_REPLACE , 
    search_class = [ torch . nn . Linear , torch . nn . Conv2d ], 
    r = 32
)

# Add LoRA to the Text Encoder
add_lora_to ( pipeline . text_encoder , target_module = TEXT_ENCODER_REPLACE , r = 32 )

# Your optimizers and training code...

Después de agregar el Lora a su modelo, puede agregar fácilmente parámetros de optimizador sabio de parámetros si es necesario.

 # Example

unet_params = []
text_encoder_params = []

for n , p in unet . named_parameters ():
    if 'lora' in n :
        unet_params . append ({
            "params" : p , 
            "lr" : args . learning_rate
        })

for n , p in text_encoder . named_parameters ():
    if 'lora' in n :
        text_encoder_params . append ({
            "params" : p , 
            "lr" : args . learning_rate_text
        })

optimizer_params = unet_params + text_encoder_params

El ahorro se puede hacer usando Safetensors o la forma tradicional, utilizando archivos .pt :

 from stable_lora . lora import save_lora

save_lora ( unet , path = 'save_file_path.safetensors' )
save_lora ( text_encoder = text_encoder , use_safetensors = False , path = 'save_file_path.pt' )

Además, puede configurar el modo en modo de evaluación o tren.

 from stable_lora . lora import set_mode

# Train mode
set_mode ( unet , is_train = True )

# Evaluation mode
set_mode ( unet , is_train = False )

Consejos

Esto se ha probado en modelos basados ​​en la difusión 1.5 estable.

Se recomienda probar las tasas de aprendizaje 5e-6 , 3e-5 y 1e-4 .

El rango predeterminado es 32 , pero se puede establecer pasándolo a través del parámetro r El uso de rangos más bajos consumirá menos memoria, con altos rangos que consuman más. Esto también contribuye a los tamaños de guardado de archivos.

Estos factores dependerán únicamente de su tarea, pero son un buen punto de partida.

También puede habilitar los prejuicios para entrenar también.

Dependiendo de sus datos y tasa de aprendizaje, es posible que pueda expulsar el rendimiento adicional de la capacitación.

 # Example | Applicable to Unet or Text Encoder

lora_bias = 'lora_only'
add_lora_to ( pipeline . text_encoder , target_module = TEXT_ENCODER_REPLACE , r = 32 , lora_bias = lora_bias )

# Must be set here as well when saving.
save_lora ( text_encoder = text_encoder , use_safetensors = True , path = 'save_file_path.pt' , lora_bias = lora_bias )

HACER

• Agregue los guiones de entrenamiento de difusores para Dreambooth y Finetuning.
• Implemente guardado y carga de Lora ( PT y safetensors ).
• Guarde Lora para la compatibilidad de WebUI.
• Agregue como una extensión de WebUI automática1111 para cargar Lora capacitada.
• Posibles integraciones para la capacitación de WebUI.

Créditos

Clonofsimo para su código de implementación de Lora.

Microsoft para el código oficial.