Prompt Tuning

L'ajustement d'invite adapte un modèle de fondation préentraîné à une nouvelle tâche en entraînant un petit ensemble de vecteurs, appelé invite souple, placé avant l'entrée tandis que tous les poids du modèle restent figés. L'invite souple se trouve dans le même espace que les plongements de jetons du modèle, mais ses vecteurs sont appris par rétropropagation et n'ont pas besoin de correspondre à des mots réels. Brian Lester, Rami Al-Rfou et Noah Constant, de Google, ont présenté cette méthode dans The Power of Scale for Parameter-Efficient Prompt Tuning, présenté à EMNLP 2021. Ils ont noté qu'une invite de cinq jetons pour le modèle T5-XXL à 11 milliards de paramètres ne nécessite que 20 480 paramètres par tâche, et montré qu'à mesure que les modèles dépassent le milliard de paramètres, l'ajustement d'invite atteint la précision de l'ajustement de l'ensemble du modèle.

Fonctionnement de l'ajustement d'invite#

Un grand modèle de langage (LLM) transforme chaque jeton d'entrée en vecteur de plongement avant que les couches Transformer ne le traitent. L'ajustement d'invite ajoute k vecteurs au début de cette séquence ; Lester et ses collègues ont testé des longueurs de 1 à 150 et utilisé 100 par défaut. Pendant l'entraînement, la fonction de perte de la tâche est rétropropagée à travers le réseau figé jusqu'à l'entrée, et l'optimiseur ne met à jour que les vecteurs de l'invite. Le résultat est un petit tenseur par tâche. Comme le modèle lui-même ne change jamais, supprimer l'invite rétablit son comportement initial sans risque d'oubli catastrophique ; une seule copie déployée peut servir plusieurs tâches simultanément, chaque requête d'un lot utilisant sa propre invite souple, ce que Lester et ses collègues appellent l'inférence à tâches mixtes.

L'exemple PyTorch suivant ajuste une invite souple de 8 vecteurs pour l'analyse de sentiments sur un GPT-2 figé des Transformers de Hugging Face, avec quatre avis d'entraînement et huit avis de test :

import torch
from torch.nn.functional import cross_entropy
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2").requires_grad_(False)  # freeze all 124M weights
embed = model.get_input_embeddings()

# Soft prompt: 8 trainable vectors in GPT-2's embedding space, initialized from the word " review"
soft_prompt = torch.nn.Parameter(embed.weight[tokenizer.encode(" review")].repeat(8, 1).clone())
optimizer = torch.optim.Adam([soft_prompt], lr=0.01)
labels = tokenizer.encode(" positive negative")  # token ids for label 0 and label 1

# Reviews alternate between positive (label 0) and negative (label 1)
train = ["Loved every minute.", "A waste of time.", "Great story and acting.", "Boring and slow."]
test = ["What a wonderful film.", "I fell asleep halfway.", "A fantastic ending.", "Terrible dialogue."]
test += ["A joy to watch.", "Dull and predictable.", "Superb from start to end.", "I want my money back."]


def label_scores(text):
    """Score both label tokens after the soft prompt and the review."""
    ids = tokenizer.encode(f"{text} Sentiment:", return_tensors="pt")
    return model(inputs_embeds=torch.cat([soft_prompt[None], embed(ids)], dim=1)).logits[0, -1, labels]


def correct():
    """Count held-out reviews whose higher-scoring label is right."""
    with torch.no_grad():
        return sum(int(label_scores(text).argmax()) == i % 2 for i, text in enumerate(test))


print(f"Held-out reviews correct before tuning: {correct()}/8")
for step in range(30):
    loss = sum(cross_entropy(label_scores(text), torch.tensor(i % 2)) for i, text in enumerate(train))
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
print(f"After tuning: {correct()}/8, training {soft_prompt.numel():,} of {model.num_parameters():,} parameters")

Il affiche Held-out reviews correct before tuning: 5/8, puis After tuning: 7/8, training 6,144 of 124,439,808 parameters. Trente étapes d'Adam sur quatre exemples ont modifié seulement 6 144 nombres, soit 0,005 % du modèle, et GPT-2 figé a correctement classé deux avis inédits supplémentaires.

Ajustement de préfixe et ajustement d'invite visuelle#

L'ajustement d'invite appartient à une famille de méthodes d'invites continues relevant de l'ajustement fin efficace en paramètres (PEFT). L'ajustement de préfixe de Xiang Lisa Li et Percy Liang apprend des vecteurs ajoutés au début de chaque couche Transformer, soit environ 0,1 % des paramètres de GPT-2 ou BART, et a égalé l'ajustement fin complet pour la génération de texte à partir de tableaux et le résumé. L'ajustement d'invite simplifie cette méthode en apprenant des vecteurs uniquement à la couche d'entrée.

Cette idée s'étend à la vision. Le Visual Prompt Tuning (VPT) de Menglin Jia et ses collègues ajoute des jetons apprenables aux jetons de patch d'un Vision Transformer (ViT) figé, entraînant moins de 1 % des paramètres, et a surpassé l'ajustement fin complet dans de nombreux contextes de classification d'images. Pour les modèles vision-langage, le Context Optimization (CoOp) de Kaiyang Zhou et ses collègues remplace les mots rédigés manuellement dans une invite CLIP, comme « une photo de », par des vecteurs appris. Sur 11 jeux de données, CoOp a surpassé les invites élaborées à la main avec un ou deux exemples annotés par classe et les a améliorées d'environ 15 % en moyenne avec 16 exemples par classe.

Les détecteurs à vocabulaire ouvert s'adaptent de manière similaire. Ultralytics YOLOE transforme les noms de classes en plongements d'invites textuelles, et sa méthode de sondage linéaire pour les jeux de données personnalisés fusionne les plongements des noms de classes du jeu de données dans la convolution finale de chaque branche de classification, puis entraîne uniquement ces couches, tandis que le backbone, le neck et le reste de la tête restent figés.

Ajustement d'invite et méthodes connexes#

• Ingénierie des invites : une personne rédige l'invite sous forme de texte, parfois appelée invite rigide, et aucun entraînement n'a lieu. L'ajustement d'invite apprend l'invite à partir de données annotées et nécessite l'accès aux gradients du modèle ; il s'applique donc aux modèles à poids ouverts.
• Ajustement fin complet : met à jour chaque poids, créant une copie complète du modèle par tâche et risquant l'oubli catastrophique des compétences antérieures. Lester et ses collègues ont constaté que les modèles ajustés par invite résistaient également mieux au décalage de domaine que les modèles entièrement ajustés.
• LoRA : ajoute des matrices de faible rang entraînables aux couches de poids du modèle. L'ajustement d'invite laisse les couches intactes et ne modifie que l'entrée.
• Apprentissage few-shot dans l'invite : place des exemples annotés dans la fenêtre de contexte sous forme de texte à chaque requête. Une invite souple ajustée stocke ce que les exemples enseignent dans quelques vecteurs et n'ajoute que k positions d'entrée.