IA3

IA3 est un excellent choix lorsque vous avez besoin de la taille d’adaptateur la plus réduite possible — il utilise des vecteurs appris plutôt que des matrices de faible rang, ce qui en fait l’une des méthodes les plus économes en paramètres disponibles. Si votre priorité est une empreinte disque/mémoire minimale et une formation rapide, IA3 est un candidat solide.

Infused Adapter par inhibition et amplification des activations internes, ou IA3, est une méthode qui ajoute trois vecteurs appris pour redimensionner les clés et les valeurs des couches d'auto-attention et d'attention encodeur-décodeur, ainsi que l'activation intermédiaire du réseau de propagation avant position par position.

L'abstract de l'article est :

L’apprentissage en contexte avec peu d’exemples (Few-shot in-context learning, ICL) permet aux modèles de langage pré-entraînés d’exécuter une tâche inédite sans entraînement par gradient, en fournissant un petit nombre d’exemples d’entraînement comme partie intégrante de l’entrée. L’ICL engendre des coûts de calcul, de mémoire et de stockage considérables, car il implique de traiter tous les exemples d’entraînement à chaque fois qu’une prédiction est effectuée. L’ajustement fin efficace en termes de paramètres (Parameter-efficient fine-tuning, PEFT) (par exemple, modules adaptateurs, ajustement par prompts, méthodes de mise à jour creuse, etc.) offre un paradigme alternatif où un petit ensemble de paramètres est entraîné pour permettre au modèle d’exécuter la nouvelle tâche. Dans cet article, nous comparons rigoureusement l’ICL avec peu d’exemples et le PEFT, et démontrons que ce dernier offre une meilleure précision ainsi que des coûts de calcul nettement inférieurs. Au passage, nous introduisons une nouvelle méthode PEFT appelée (IA)^3 qui met à l’échelle les activations par des vecteurs appris, atteignant des performances supérieures tout en n’ajoutant qu’une quantité relativement faible de nouveaux paramètres. Nous proposons également une recette simple basée sur le modèle T0, appelée T-Few, qui peut être appliquée à de nouvelles tâches sans ajustement spécifique à la tâche ni modifications. Nous validons l’efficacité de T-Few sur des tâches totalement inédites en l’appliquant au benchmark RAFT, atteignant pour la première fois des performances supérieures à celles de l’humain et surpassant l’état de l’art de 6 % en absolu. Tout le code utilisé dans nos expériences est publiquement disponible.

Pour rendre le fine-tuning plus efficace, IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations) rééchelonne les activations internes à l'aide de vecteurs appris. Ces vecteurs appris sont injectés dans les modules d'attention et de feedforward d'une architecture basée sur un transformer classique. Ces vecteurs appris sont les seuls paramètres entraînables lors du fine-tuning, et les poids d'origine restent donc figés. Le fait de manipuler des vecteurs appris (par opposition à des mises à jour de faible rang d'une matrice de poids, comme avec LoRA) permet de garder le nombre de paramètres entraînables beaucoup plus faible.

De par sa similitude avec LoRA, IA3 présente de nombreux avantages communs :

• IA3 rend le fine-tuning plus efficace en réduisant considérablement le nombre de paramètres entraînables. (Pour T0, un modèle IA3 ne possède que 0,01 % de paramètres entraînables environ, tandis que même LoRA en a > 0,1 %)
• Les poids pré-entraînés d’origine sont maintenus figés, ce qui signifie que vous pouvez disposer de plusieurs modèles IA3 légers et portables pour diverses tâches en aval, construits sur leur base.
• Les performances des modèles affinés à l'aide de IA3 sont comparables à celles des modèles entièrement affinés.
• IA3 n'ajoute aucune latence d'inférence car les poids de l'adaptateur peuvent être fusionnés avec le modèle de base.

En principe, IA3 peut être appliqué à n’importe quel sous-ensemble de matrices de poids d’un réseau de neurones afin de réduire le nombre de paramètres entraînables. Conformément à l’implémentation des auteurs, les poids IA3 sont ajoutés aux couches clé, valeur et feedforward d’un modèle Transformer. Plus précisément, pour les modèles transformer, les poids IA3 sont ajoutés aux sorties des couches clé et valeur, ainsi qu’à l’entrée de la deuxième couche feedforward de chaque bloc transformer.

Étant donné les couches cibles pour l'injection des paramètres IA3, le nombre de paramètres entraîlables peut être déterminé en fonction de la taille des matrices de poids.

Utilisation

Pour les modèles autorégressifs, ciblez k_proj, v_proj et down_proj — ce sont les couches que les auteurs ont jugées les plus efficaces. Définissez feedforward_modules=["down_proj"] afin que IA3 sache quelles modules sont des couches feedforward et puisse appliquer le bon échelonnement.

Pour la tâche de classification de séquences, on peut initialiser la configuration IA3 pour un modèle Llama comme suit :

from peft import IA3Config, TaskType, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM-135M")
peft_config = IA3Config(
    task_type=TaskType.CAUSAL_LM,
    target_modules=["k_proj", "v_proj", "down_proj"],
    feedforward_modules=["down_proj"],
)
model = get_peft_model(model, peft_config)
model.print_healthcheck()

Quand utiliser IA3 plutôt que LoRA

IA3 est particulièrement efficace lorsque vous avez besoin des adaptateurs les plus petits possibles pour des déploiements contraints en stockage, ou lorsque vous souhaitez une convergence rapide avec un nombre réduit de paramètres entraînables. LoRA peut être préférable si vous avez besoin de l’écosystème plus large des variantes de LoRA (DoRA, QLoRA, etc.) ou si vous souhaitez l’approche la plus largement testée, bénéficiant d’un soutien communautaire important.

Aperçu des benchmarks

API

IA3Config

IA3Model

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import IA3Config, get_peft_model

>>> config = IA3Config(
...     peft_type="IA3",
...     task_type="SEQ_2_SEQ_LM",
...     target_modules=["k", "v", "w0"],
...     feedforward_modules=["w0"],
... )

>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> ia3_model = get_peft_model(model, config)