AmeliorIA

tekio.org

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

  1. 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.
  2. Calcule C sur 200 paragraphes wikitext, puis applique les 4 éditions ROME l'une après l'autre.
  3. 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_proj de la couche 5 (couche_relative: 0.2 × 28 couches, numérotées à partir de 0).
  • ④ Mesure avant. run.py compare, 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.py appelle edition.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.py appelle edition.rome pour chaque fait, l'un après l'autre, sur le même modèle.
  • ⑪ Calcul sur le GPU. Pour chaque fait, edition.py calcule 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/, puis 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 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).