AmeliorIA

tekio.org

Exemple de code : Pilotage par activations

Ce que le dossier 11-pilotage-activations/ fournit pour cette méthode. Principe et références : Pilotage par activations.

Ce que fait l'exemple

  1. Extrait la direction « positif - négatif » sur 15 paires de phrases, à mi-profondeur.
  2. Mesure le taux de textes jugés positifs sans intervention, sur des consignes neutres et sur des demandes de texte négatif.
  3. Mode vecteur : la même mesure pour chaque α. Attendu : α > 0 augmente fortement le taux positif, même pour les demandes négatives ; α < 0 le fait chuter.
  4. Mode ablation : attendu, les demandes de texte négatif produisent des textes nettement moins négatifs, avec des poids modifiés de façon permanente.

Composants de l'exemple

flowchart TD
  classDef externe fill:#fed7aa,stroke:#ea580c,color:#7c2d12
  classDef code fill:#ffffff,stroke:#6b7280,color:#1f2937
  classDef gpu fill:#fecaca,stroke:#dc2626,color:#7f1d1d
  classDef disque fill:#dcfce7,stroke:#16a34a,color:#14532d

  Hub["Hugging Face Hub<br/>Qwen2.5-1.5B-Instruct<br/>DistilBERT SST-2"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>direction d, α<br/>génération"]
    Hook["forward hook<br/>couche 14 sur 28"]
    Clf["pipeline transformers<br/>classifieur"]
  end
  GPU["GPU CUDA, 12 Go"]
  Out[("sorties/<br/>11-pilotage-activations/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids (3 Go + 270 Mo)" --> Cache
  Cache -- "② lecture des poids" --> Run
  Run -- "④ ⑨ appel Python<br/>pose du hook" --> Hook
  Hook -- "⑤ ⑩ hook sur les activations<br/>lecture, puis ajout α·d" --> GPU
  Run -- "③ copie des poids<br/>⑥ génération" --> GPU
  Run -- "⑦ ⑪ appel Python<br/>textes à juger" --> Clf
  Clf -- "⑧ ⑫ noyaux CUDA<br/>classification" --> GPU
  Run -- "⑬ écriture" --> Out
  GPU ~~~ Out

  class Hub externe
  class Run,Hook,Clf code
  class GPU gpu
  class Cache,Out disque

make run EX=EDIT11 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, mode vecteur, couche, intensités α, évaluation). Toutes les phrases sont écrites dans run.py, sans téléchargement : 15 paires de phrases de sentiment opposé (« I absolutely love the weather… » / « I absolutely hate the weather… »), 30 consignes neutres (« Write one sentence about the movie. ») et 30 demandes de texte négatif (« Write an angry complaint about the hotel. »).

  • ① Téléchargement. Au premier lancement, transformers télécharge depuis le Hugging Face Hub, par HTTPS, les poids de Qwen2.5-1.5B-Instruct (environ 3 Go) et ceux du classifieur de sentiment distilbert-base-uncased-finetuned-sst-2-english (environ 270 Mo).
  • ② Lecture. Les poids sont rangés dans le cache ~/.cache/huggingface ; les lancements suivants les relisent sur le disque, sans réseau.
  • ③ Copie sur le GPU. Les deux modèles sont copiés dans la mémoire du GPU, le LLM en bf16. Ses poids sont gelés : rien n'est entraîné.
  • ④ Pose du hook de lecture. run.py accroche un forward hook PyTorch à la sortie du bloc 14 sur 28, au milieu du modèle (couche_relative: 0.5).
  • ⑤ Extraction de la direction. Chacune des 30 phrases passe dans le modèle ; à chaque passage, le hook copie l'activation du flux résiduel au dernier token. La direction d est la moyenne des activations positives moins celle des négatives. Le hook est ensuite retiré.
  • ⑥ Génération sans intervention. Le modèle répond aux 30 consignes neutres et aux 30 demandes négatives, en génération gloutonne jusqu'à 48 tokens, par lots de 16.
  • ⑦ Jugement. Les textes produits sont passés au classifieur, via la pipeline("sentiment-analysis") de transformers.
  • ⑧ Classification sur le GPU. Le classifieur rend POSITIVE ou NEGATIVE pour chaque texte ; le résultat est le taux de textes positifs.
  • ⑨ Pose du hook de pilotage, une fois pour chaque α de la liste [-2.0, 1.0, 2.0].
  • ⑩ Génération pilotée. Les mêmes 60 consignes sont reposées, avec le même décodage qu'en ⑥. À chaque passe avant, le hook remplace la sortie du bloc 14 par cette sortie plus α·d, à toutes les positions. Les poids ne changent pas : retirer le hook rend le modèle d'origine.
  • ⑪ Jugement des textes pilotés.
  • ⑫ Classification sur le GPU, comme en ⑧.
  • ⑬ Écriture de la direction dans sorties/11-pilotage-activations/direction.pt et du rapport dans resultats.json, avec le même tableau affiché dans le terminal.

Ce que fait le GPU. Le processus Python ne calcule presque rien lui-même : PyTorch envoie au GPU des « noyaux CUDA », de petits programmes qui font les multiplications de matrices et l'attention sur les poids et les activations déjà présents dans sa mémoire. Il n'y a ni passe arrière ni optimiseur : tout le travail est de l'inférence. En génération (⑥, ⑩), il y a une passe avant par token produit, accélérée par un cache des clés et des valeurs déjà calculées. Le hook est une fonction Python appelée par PyTorch au milieu de chaque passe avant ; l'addition α·d qu'elle demande est elle-même un noyau CUDA sur le tenseur d'activations, qui ne quitte pas la mémoire du GPU. Le classifieur (⑧, ⑫) ne fait qu'une passe avant par lot de textes.

Ce qui est écrit.

Fichier Contenu
direction.pt La direction d, un vecteur de la taille du flux résiduel (fichier de 8 Ko), le numéro de couche et le nom du modèle : de quoi piloter à nouveau ce modèle sans réextraire
resultats.json Pour sans_intervention et pour chaque alpha_-2.0, alpha_1.0, alpha_2.0 : le taux_positif sur les consignes neutres et sur les demandes négatives, avec un texte d'exemple de chaque côté
config_effective.yaml La configuration réellement utilisée, surcharges SET comprises

Avec SET="pilotage.mode=ablation", la direction est retirée des matrices qui écrivent dans le flux résiduel, et le dossier modele-ablation/ contient le modèle complet aux poids modifiés, à la place de direction.pt.

Essayer dans le dépôt

Exemple Statut Résultat mesuré Durée Commande
exemple principal démontré taux de réponses positives 0,60 → 0,97 — n = 30 par condition test : 12 s
complet : 27 s
make test EX=EDIT11
non testé version grosse infra jamais exécutée 11-pilotage-activations/infra/

Résultats et durées mesurés sur RTX 5070 Ti Laptop (12 Go, 11,5 Gio utilisables), 30 Go de RAM ; résultats de la configuration complète. make test lance un test rapide sur un petit modèle ; make run lance l'exemple complet ; make verifier contrôle d'abord les prérequis. Installation : Installer et lancer.

make install EXTRAS=1
make test EX=EDIT11
make run EX=EDIT11

Utilisation

python run.py --quick
python run.py                                                  # vecteur de sentiment, Qwen2.5-1.5B-Instruct, α ∈ {-2, 1, 2}
python run.py --set pilotage.couche_relative=0.3               # la couche change beaucoup l'effet
python run.py --set pilotage.mode=ablation                     # retire la direction des poids et sauvegarde le modèle
python run.py --set "pilotage.alphas=[-4, 4]"

Paramètres principaux

Clé Rôle
pilotage.mode vecteur ou ablation
pilotage.couche / couche_relative Couche d'extraction et d'injection
pilotage.alphas Intensités testées (multiples de l'écart moyen)
pilotage.n_paires Nombre de paires contrastives

Grosse infra

  • Inférence seulement : un 70B tient sur un nœud de 2 à 4 GPU 80 Go en device_map=auto (infra/config.yaml). Pas d'entraînement distribué.
  • En production (infra/lancer.sh) :
    • modèle ablaté servi comme n'importe quel checkpoint ;
    • vecteurs dynamiques via llama.cpp (--control-vector), repeng, EasySteer (vLLM) ;
    • pilotage par features de SAE (Gemma Scope, Llama Scope, SAELens).