Stable LoRA

Lora stable (WIP)

Train Lora en utilisant l'implémentation officielle de Microsoft avec des modèles de diffusion stables. C'est le moyen le plus efficace et le plus simple de former des loras sans la complexité supplémentaire tout en étant partageable entre les bibliothèques et les implémentations.

? Ce repo est toujours en développement actif. Attendez-vous à des bugs jusqu'à ce que l'indicateur WIP soit supprimé. ?

Commencer

Clone ce référentiel dans votre dossier de formation:

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

Installez les exigences de ce référentiel:

pip install -r requirements.txt

Exemple

La formation est effectuée en utilisant la bibliothèque Diffusers.

Voir Example_TRAIN_Script.sh pour un exemple de script de Dreambooth.

Courir est aussi simple que de faire:

 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"

Après la formation, les résultats seront enregistrés dans votre dossier de sortie.

Par défaut, une variante WebUI Automatic1111 est enregistrée à côté d'eux (l'extension WebUI est en développement).

Développeurs

Ajoutez-le simplement à votre modèle avant la boucle d'entraînement.

 # 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...

Après avoir ajouté la LORA à votre modèle, vous pouvez facilement ajouter des paramètres d'optimiseur par des paramètres si nécessaire.

 # 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

La sauvegarde peut être effectuée à l'aide de SafeTtenseurs ou de la manière traditionnelle, en utilisant des fichiers .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' )

De plus, vous pouvez définir le mode sur le mode évaluation ou train.

 from stable_lora . lora import set_mode

# Train mode
set_mode ( unet , is_train = True )

# Evaluation mode
set_mode ( unet , is_train = False )

Conseils

Ceci a été testé sur des modèles basés sur la diffusion 1.5 stables.

Il est recommandé d'essayer les taux d'apprentissage 5e-6 , 3e-5 et 1e-4 .

Le rang par défaut est 32 , mais peut être défini en le faisant passer par le paramètre r L'utilisation de rangs inférieurs consommera moins de mémoire, avec des rangs élevés consommant plus. Cela contribue également à des tailles de sauvegarde de fichiers.

Ces facteurs dépendront uniquement de votre tâche, mais sont un bon point de départ.

Vous pouvez également permettre aux biais de vous entraîner également.

Selon vos données et votre taux d'apprentissage, vous pourrez peut-être extraire des performances supplémentaires de la formation.

 # 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 )

FAIRE

• Ajoutez des scripts de formation des diffuseurs pour Dreambooth et Finetuning.
• Implémentez la sauvegarde et le chargement de LORA ( PT & safetensors ).
• Enregistrez Lora pour la compatibilité WebUI.
• Ajouter comme une extension Webui Automatic1111 pour le chargement de Lora formé.
• Intégations possibles pour la formation Webui.

Crédits

CloneofSimo pour leur code d'implémentation LORA.

Microsoft pour le code officiel.