Configurations et modèles PEFT

La taille considérable des grands modèles pré-entraînés d’aujourd’hui – qui comptent couramment des milliards de paramètres – représente un défi majeur pour l’entraînement, car ils nécessitent davantage d’espace de stockage et de puissance de calcul pour effectuer toutes ces opérations. Il faut disposer de GPU ou de TPU puissants pour entraîner ces grands modèles pré-entraînés, ce qui est coûteux, peu accessible à tous, peu respectueux de l’environnement et peu pratique. Les méthodes PEFT répondent à bon nombre de ces défis. Il existe plusieurs types de méthodes PEFT (soft prompting, décomposition de matrices, adaptateurs), mais elles se concentrent toutes sur le même objectif : réduire le nombre de paramètres entraînables. Cela rend l’entraînement et le stockage de grands modèles plus accessibles sur du matériel grand public.

La bibliothèque PEFT est conçue pour vous aider à entraîner rapidement de grands modèles sur des GPU gratuits ou à faible coût. Dans ce tutoriel, vous apprendrez à configurer un paramétrage pour appliquer une méthode PEFT à un modèle de base pré-entraîné en vue de l’entraînement. Une fois la configuration PEFT en place, vous pouvez utiliser le framework d’entraînement de votre choix (la classe Trainer de Transformers, Accelerate, une boucle d’entraînement PyTorch personnalisée).

Configurations PEFT

En savoir plus sur les paramètres que vous pouvez configurer pour chaque méthode PEFT sur leur page de référence API respective.

Une configuration stocke les paramètres importants qui spécifient la manière dont une méthode PEFT particulière doit être appliquée.

Par exemple, examinez la configuration LoraConfig suivante pour appliquer LoRA et la configuration PromptEncoderConfig pour appliquer p-tuning (ces fichiers de configuration sont déjà sérialisés en JSON). Chaque fois que vous chargez un adaptateur PEFT, il est judicieux de vérifier qu'il est associé à un fichier adapter_config.json, qui est requis.

{
  "base_model_name_or_path": "facebook/opt-350m", #base model to apply LoRA to
  "bias": "none",
  "fan_in_fan_out": false,
  "inference_mode": true,
  "init_lora_weights": true,
  "layers_pattern": null,
  "layers_to_transform": null,
  "lora_alpha": 32,
  "lora_dropout": 0.05,
  "modules_to_save": null,
  "peft_type": "LORA", #PEFT method type
  "r": 16,
  "revision": null,
  "target_modules": [
    "q_proj", #model modules to apply LoRA to (query and value projection layers)
    "v_proj"
  ],
  "task_type": "CAUSAL_LM" #type of task to train model on
}

from peft import LoraConfig, TaskType

lora_config = LoraConfig(
    r=16,
    target_modules=["q_proj", "v_proj"],
    task_type=TaskType.CAUSAL_LM,
    lora_alpha=32,
    lora_dropout=0.05
)

{
  "base_model_name_or_path": "roberta-large", #base model to apply p-tuning to
  "encoder_dropout": 0.0,
  "encoder_hidden_size": 128,
  "encoder_num_layers": 2,
  "encoder_reparameterization_type": "MLP",
  "inference_mode": true,
  "num_attention_heads": 16,
  "num_layers": 24,
  "num_transformer_submodules": 1,
  "num_virtual_tokens": 20,
  "peft_type": "P_TUNING", #PEFT method type
  "task_type": "SEQ_CLS", #type of task to train model on
  "token_dim": 1024
}

from peft import PromptEncoderConfig, TaskType

p_tuning_config = PromptEncoderConfig(
    encoder_reparameterization_type="MLP",
    encoder_hidden_size=128,
    num_attention_heads=16,
    num_layers=24,
    num_transformer_submodules=1,
    num_virtual_tokens=20,
    token_dim=1024,
    task_type=TaskType.SEQ_CLS
)

Modèles PEFT

Une fois la configuration PEFT en main, vous pouvez l’appliquer à n’importe quel modèle pré-entraîné pour créer un PeftModel. Choisissez parmi les modèles de pointe de la bibliothèque Transformers, un modèle personnalisé, voire de nouvelles architectures de transformeurs non prises en charge.

Pour ce tutoriel, chargez un modèle de base facebook/opt-350m à affiner.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")

Utilisez la fonction get_peft_model() pour créer un PeftModel à partir du modèle de base facebook/opt-350m et de la configuration lora_config que vous avez créée précédemment.

from peft import get_peft_model

lora_model = get_peft_model(model, lora_config)
lora_model.print_healthcheck()

Lors de l’appel de get_peft_model(), le modèle de base est modifié in-place. Cela signifie que si vous appelez get_peft_model() sur un modèle qui a déjà été modifié de la même manière auparavant, ce modèle sera encore davantage altéré. Par conséquent, si vous souhaitez modifier votre configuration PEFT après avoir appelé get_peft_model() précédemment, vous devez d’abord décharger le modèle avec unload() puis appeler get_peft_model() avec votre nouvelle configuration. Alternativement, vous pouvez réinitialiser le modèle pour vous assurer d’un état neuf et non modifié avant d’appliquer une nouvelle configuration PEFT.

Vous pouvez maintenant entraîner le PeftModel avec votre framework d’entraînement préféré ! Une fois l’entraînement terminé, vous pouvez enregistrer votre modèle localement avec save_pretrained() ou le téléverser sur le Hub à l’aide de la méthode push_to_hub.

# save locally
lora_model.save_pretrained("your-name/opt-350m-lora")

# push to Hub
lora_model.push_to_hub("your-name/opt-350m-lora")

Pour charger un PeftModel pour l'inférence, vous devez fournir le PeftConfig utilisé pour le créer ainsi que le modèle de base à partir duquel il a été entraîné.

from peft import PeftModel, PeftConfig

config = PeftConfig.from_pretrained("ybelkada/opt-350m-lora")
model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora")

Par défaut, le PeftModel est configuré pour l’inférence, mais si vous souhaitez entraîner davantage l’adaptateur, vous pouvez définir is_trainable=True.

Copié

lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora", is_trainable=True)

La méthode PeftModel.from_pretrained() est la manière la plus flexible de charger un PeftModel, car le framework de modèle utilisé (Transformers, timm, un modèle PyTorch générique) n’a pas d’importance. Les autres classes, comme AutoPeftModel, ne sont qu’un wrapper pratique autour de la classe de base PeftModel, et facilitent le chargement direct des modèles PEFT depuis le Hub ou localement, là où les poids PEFT sont stockés.

from peft import AutoPeftModelForCausalLM

lora_model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora")

Consultez la référence de l’API AutoPeftModel pour en savoir plus sur les classes AutoPeftModel.

Étapes suivantes

Avec la PeftConfig appropriée, vous pouvez l’appliquer à n’importe quel modèle pré-entraîné pour créer un PeftModel et entraîner de grands modèles puissants plus rapidement sur des GPU librement disponibles ! Pour en savoir plus sur les configurations et les modèles PEFT, le guide suivant peut s’avérer utile :

• Apprenez à configurer une méthode PEFT pour des modèles qui ne proviennent pas de Transformers dans le guide Travailler avec des modèles personnalisés.