# PaCA : adaptation de la connexion partielle [PaCA](https://huggingface.co/papers/2503.01905) (ICLR 2025) est une méthode PEFT qui vise la vitesse d’entraînement et la mémoire d’activation. Elle ajuste finement `r` colonnes d’entrée sélectionnées aléatoirement (« connexions partielles ») de chaque poids pré-entraîné ciblé. Les seuls paramètres entraînables sont les mises à jour de ces colonnes ; contrairement à LoRA, PaCA n’ajoute aucune matrice de faible rang supplémentaire. Des méthodes telles que LoRA exécutent une petite branche de faible rang à côté de chaque couche pré-entraînée. Cette branche nécessite peu de FLOPs, mais elle est exécutée séquentiellement avec la couche pré-entraînée et conserve sa propre copie de l’activation d’entrée pour le passage arrière. PaCA évite les deux : - **Un seul GEMM par couche.** Les colonnes adaptées sont écrites dans le poids préentraîné juste avant sa multiplication matricielle et restaurées juste après, de sorte que les passes avant et arrière exécutent chacune une seule multiplication matricielle, exactement comme la couche de base gelée. - **Activations partielles.** Le gradient des colonnes adaptées ne dépend que des `r` canaux d’entrée correspondants, seuls ceux-ci sont donc conservés pour le passage arrière au lieu de l’entrée complète. En termes de poids résultants, un adaptateur PaCA est équivalent à un adaptateur LoRA de rang `r` dont la matrice `A` est un sélecteur de colonnes fixe : `W' = W + delta @ S`, où `S` sélectionne les `r` colonnes. Il peut donc être converti en un adaptateur LoRA de rang `r` sans perte via [convert_to_lora()](/docs/peft/main/fr/package_reference/lora_conversion#peft.convert_to_lora), par exemple pour le servir avec une pile d'inférence LoRA. Quand utiliser PaCA : - Vous souhaitez une précision au niveau de LoRA, mais avec des étapes de fine-tuning plus rapides et une mémoire d'activation plus faible, par exemple pour traiter des séquences plus longues ou des lots plus volumineux sur le même GPU. - Vous souhaitez un adaptateur qui fusionne exactement dans les poids de base (la mise à jour est une simple mise à jour de colonne). Contraintes actuelles : - Seules les couches `nn.Linear` (y compris les couches linéaires quantifiées) sont prises en charge. - PaCA exécute lui-même la multiplication matricielle au lieu d'appeler la méthode `forward` de la couche de base, de sorte que les hooks de forward enregistrés sur la couche de base ne sont pas appelés (un avertissement est émis). Enregistrez les hooks sur la couche PaCA à la place. - Les lots d'adaptateurs mixtes (argument `adapter_names`) ne sont pas pris en charge. - L'entraînement avec des poids fragmentés (FSDP, DeepSpeed ZeRO-3) n'a pas encore été testé. - `torch.compile` est pris en charge : lors de la compilation, l’échange de colonnes, le matmul et la restauration s’exécutent en tant qu’opérations personnalisées opaques (`torch.ops.peft.paca_linear_forward`/`_backward`), de sorte que le compilateur ne copie pas les poids de base. Cela nécessite `torch.library.custom_op` (PyTorch >= 2.4) ; sinon, l’implémentation eager est tracée. - `paca_alpha / r` met à l'échelle la mise à jour de la colonne et agit donc comme un multiplicateur du taux d'apprentissage effectif. - Pour l’inférence, fusionnez l’adaptateur (`merge_and_unload()`) ; le forward non fusionné continue d’échanger les colonnes à chaque appel. ## Utilisation ```python from transformers import AutoModelForCausalLM from peft import PacaConfig, get_peft_model model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B") config = PacaConfig(r=16, paca_alpha=16, target_modules="all-linear", random_seed=0) model = get_peft_model(model, config) model.print_trainable_parameters() ``` Par défaut, chaque couche ciblée ajuste `r` colonnes sélectionnées aléatoirement ; dans l’article, cela a donné des résultats comparables à la sélection des colonnes par norme de poids ou par gradients accumulés. Pour choisir vous-même les colonnes, par exemple pour essayer une autre stratégie de sélection ou pour utiliser un nombre différent de colonnes par couche, passez `paca_indices_pattern`. Ses clés sont des noms de couches ou des expressions régulières, comme dans `rank_pattern` de LoRA : ```python config = PacaConfig( r=16, paca_alpha=16, target_modules=["q_proj", "v_proj"], paca_indices_pattern={"layers.0.self_attn.q_proj": [0, 2, 4, 6], "layers.1.self_attn.v_proj": list(range(32))}, ) ``` Les couches qui correspondent à une clé affinent les colonnes données, tandis que toutes les autres couches ciblées sélectionnent `r` colonnes aléatoires. L'échelle est `paca_alpha / r` avec le `r` de la configuration dans chaque couche, de sorte que `paca_alpha` a la même signification pour toutes les couches. L'abstract de l'article est : > Les algorithmes de fine-tuning efficace en paramètres (PEFT) réduisent la consommation mémoire et les coûts de calcul du fine-tuning de grands modèles de réseaux de neurones en n'entraînant que quelques paramètres d'adaptateurs supplémentaires, plutôt que l'ensemble du modèle. Cependant, la réduction des coûts de calcul due au PEFT ne se traduit pas nécessairement par une réduction du temps d'entraînement ; bien que les coûts de calcul des couches d'adaptateurs soient beaucoup plus faibles que ceux des couches pré-entraînées, il est bien connu que ces deux types de couches sont traités séquentiellement sur les GPU, ce qui entraîne un surcoût de latence important. LoRA et ses variantes évitent ce surcoût de latence en fusionnant les matrices d'adaptateurs de faible rang avec les poids pré-entraînés lors de l'inférence. Toutefois, ces couches ne peuvent pas être fusionnées pendant l'entraînement, car les poids pré-entraînés doivent rester figés tandis que les matrices d'adaptateurs de faible rang sont mises à jour en continu au cours de l'entraînement. De plus, LoRA et ses variantes ne réduisent pas la mémoire d'activation, car la première matrice d'adaptateur de faible rang nécessite toujours les activations d'entrée des poids pré-entraînés pour calculer les gradients des poids. Pour atténuer ce problème, nous proposons l'adaptation de connexions partielles (PaCA), qui effectue le fine-tuning de connexions partielles sélectionnées aléatoirement au sein des poids pré-entraînés, au lieu d'introduire des couches d'adaptateurs dans le modèle. PaCA améliore non seulement la vitesse d'entraînement en éliminant le surcoût temporel dû au traitement séquentiel des couches d'adaptateurs et des couches pré-entraînées, mais réduit également la mémoire d'activation, car seules des activations partielles, plutôt que des activations complètes, doivent être stockées pour le calcul des gradients. Par rapport à LoRA, PaCA réduit le temps d'entraînement de 22 % et la consommation mémoire totale de 16 %, tout en maintenant une précision comparable dans divers scénarios de fine-tuning, tels que le fine-tuning sur le jeu de données MMLU et l'instruction tuning sur le jeu de données Oasst1. PaCA peut également être combiné avec la quantification, permettant le fine-tuning de grands modèles tels que LLaMA3.1-70B. En outre, PaCA permet un entraînement avec des séquences 23 % plus longues et améliore le débit de 16 % sur les GPU NVIDIA A100 et les HPU INTEL Gaudi2 par rapport à LoRA. ## Aperçu des benchmarks