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
- Extrait la direction « positif - négatif » sur 15 paires de phrases, à mi-profondeur.
- Mesure le taux de textes jugés positifs sans intervention, sur des consignes neutres et sur des demandes de texte négatif.
- 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.
- 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.pyaccroche 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
dest 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.ptet du rapport dansresultats.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).