Exemple de code : Édition de connaissances
Ce que le dossier 09-edition-connaissances/ fournit pour cette méthode. Principe et références : Édition de connaissances.
Ce que fait l'exemple
- Mesure efficacité, généralisation et spécificité sur 4 faits réels (Eiffel, Mona Lisa, Everest, Python), plus la complétion gloutonne du prompt.
- Calcule
Csur 200 paragraphes wikitext, puis applique les 4 éditions ROME l'une après l'autre. - Remesure. Attendu : efficacité et généralisation proches de 1, spécificité qui reste haute. Les complétions affichent les nouveaux objets.
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, wikitext"]
Cache[("cache disque<br/>~/.cache/huggingface")]
subgraph Py["Processus Python"]
Run["run.py<br/>charge le modèle<br/>4 faits à éditer"]
Mo["modeles.py<br/>log-probas, génération"]
Ed["edition.py<br/>ROME"]
end
GPU["GPU CUDA, 12 Go"]
Out[("sorties/<br/>09-edition-connaissances/")]
Hub -- "① ⑥ HTTPS GET, 1re fois<br/>poids, wikitext" --> Cache
Cache -- "② ⑦ lecture<br/>poids, paragraphes" --> Run
Run -- "③ copie des poids<br/>en mémoire GPU" --> GPU
Run -- "④ ⑫ appel Python<br/>mesure avant, après" --> Mo
Mo -- "⑤ ⑬ noyaux CUDA<br/>forward, génération" --> GPU
Run -- "⑧ ⑩ appel Python<br/>covariance, éditions" --> Ed
Ed -- "⑨ ⑪ noyaux CUDA<br/>forward, backward" --> GPU
Run -- "⑭ écriture<br/>modèle, resultats.json" --> Out
GPU ~~~ Out
class Hub externe
class Run,Mo,Ed code
class GPU gpu
class Cache,Out disque
make run EX=EDIT09 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, méthode rome, couche et module édités, réglages de l'optimisation) et prend les 4 faits à modifier dans commun/donnees.py : la tour Eiffel passe à Rome, la Joconde à Picasso, l'Everest aux Alpes, Python à Linus. Chaque fait vient avec 2 paraphrases (le changement doit s'y retrouver) et 2 faits voisins (ils ne doivent pas changer). Il n'y a pas de jeu d'entraînement : seuls 200 paragraphes Wikipédia servent, à estimer la statistique des activations.
- ① Téléchargement du modèle. Au premier lancement, transformers télécharge les poids de Qwen2.5-1.5B (environ 3 Go), un modèle de base et non instruct, puisque les prompts sont des débuts de phrase à compléter.
- ② 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 poids sont copiés en float32 dans la mémoire du GPU, où ils restent jusqu'à la fin, tous figés. L'édition porte sur le module
mlp.down_projde la couche 5 (couche_relative: 0.2× 28 couches, numérotées à partir de 0). - ④ Mesure avant.
run.pycompare, pour chaque fait, la probabilité de l'ancien et du nouvel objet après le prompt (efficacité), après les paraphrases (généralisation), et celle de la bonne réponse face au nouvel objet sur les faits voisins (spécificité). - ⑤ Calcul sur le GPU. Chaque comparaison est une passe avant qui donne la log-probabilité de la suite ; le prompt principal de chaque fait est aussi complété par 8 tokens en décodage glouton, pour lire la réponse du modèle.
- ⑥ Téléchargement de wikitext-2, au premier lancement, par datasets.
- ⑦ Lecture de 200 paragraphes du split
train. - ⑧ Covariance.
run.pyappelleedition.py, qui accroche une fonction à l'entrée du module édité pour recueillir ses activations, les « clés ». - ⑨ Passes avant sur le GPU. Les 200 paragraphes traversent le modèle ; la matrice de covariance C des clés (8 960 × 8 960) s'accumule, puis est inversée.
- ⑩ Éditions.
run.pyappelleedition.romepour chaque fait, l'un après l'autre, sur le même modèle. - ⑪ Calcul sur le GPU. Pour chaque fait,
edition.pycalcule la clé k* (activation au dernier token du sujet, moyennée sur 5 contextes), puis cherche la valeur v* qui fait prédire le nouvel objet : au plus 40 pas d'Adam sur un seul vecteur de 1 536 nombres, ajouté à la sortie du module, avec une pénalité qui préserve le sens général du sujet. Il écrit enfin l'association dans la matrice du module par une mise à jour de rang 1. - ⑫ Mesure après. Les mêmes comparaisons qu'en ④.
- ⑬ Calcul sur le GPU, identique à ⑤.
- ⑭ Écriture du modèle et du rapport. Le modèle complet édité est écrit dans
sorties/09-edition-connaissances/modele-rome/, puisresultats.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 déjà présents dans sa mémoire. Les mesures (⑤, ⑬) sont des passes avant, plus une courte génération par prompt. La covariance (⑨) n'est qu'une suite de passes avant, dont on garde les entrées d'un seul module. L'optimisation de v* (⑪) fait des passes avant et arrière sur 6 courtes phrases, mais le gradient ne sert qu'au vecteur de 1 536 nombres : aucun poids du modèle n'est entraîné. La seule modification des poids est la mise à jour de rang 1 de la matrice down_proj de la couche 5, W ← W + (v* − W k*)(C⁻¹ k*)ᵀ / ((C⁻¹ k*)ᵀ k*), un produit extérieur de deux vecteurs ajouté en une opération. La pondération par C⁻¹ choisit, parmi les mises à jour qui associent k* à v*, celle qui change le moins la sortie du module pour les clés du texte générique.
Ce qui est écrit.
| Fichier | Contenu |
|---|---|
modele-rome/model.safetensors |
Tous les poids du modèle après les 4 éditions (6,17 Go, en float32) ; seule une matrice de la couche 5 diffère de Qwen2.5-1.5B |
modele-rome/config.json, generation_config.json |
Architecture Qwen2 et réglages de génération, pour recharger le modèle avec AutoModelForCausalLM.from_pretrained |
modele-rome/tokenizer.json, tokenizer_config.json, chat_template.jinja |
Le tokenizer, copié pour que le dossier se suffise à lui-même |
resultats.json |
Avant et après : efficacité, généralisation, spécificité, et la complétion de chaque prompt (« The Eiffel Tower is located in the city of » → « Rome, Italy. It is the largest » après édition) ; norme de chaque mise à jour de rang 1 |
config_effective.yaml |
La configuration réellement utilisée, surcharges SET comprises |
Avec SET="edition.methode=ft_contraint", le modèle est écrit dans modele-ft_contraint/.
Essayer dans le dépôt
| Exemple | Statut | Résultat mesuré | Durée | Commande |
|---|---|---|---|---|
| exemple principal | démontré | efficacité 0 → 1 ; généralisation 0 → 1 ; spécificité 1 → 1 — n = 4 faits | test : 12 s complet : 48 s |
make test EX=EDIT09 |
| non testé version grosse infra | jamais exécutée | 09-edition-connaissances/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=EDIT09
make run EX=EDIT09
Utilisation
python run.py --quick
python run.py # ROME, 4 éditions successives sur Qwen2.5-1.5B
python run.py --set edition.methode=ft_contraint # comparaison FT-L
python run.py --set edition.couche=12 # éditer plus haut : spécificité et généralisation changent
python run.py --set modele.nom=meta-llama/Llama-3.2-1B
Paramètres principaux
| Clé | Rôle |
|---|---|
edition.methode |
rome ou ft_contraint |
edition.module, couche / couche_relative |
Matrice éditée |
pas_valeur, lr_valeur, poids_kl, norme_max |
Optimisation de v* |
amortissement |
Stabilise l'inversion de C |
Grosse infra
- ROME sur 7-8B : 1 GPU 40-80 Go (
infra/config.yaml). - MEMIT sur 1 000 faits CounterFact avec EasyEdit :
infra/memit_easyedit.py+infra/memit_llama3-8b.yaml. Le coût dominant est le calcul unique des statistiques de covariance (~100k échantillons Wikipédia). infra/lancer.sh: édition puis contrôle de non-régression (MMLU, HellaSwag).- Pas besoin de multi-nœuds : l'édition reste une opération légère. Les modèles 70B demandent un nœud multi-GPU (
model_parallel: true).