AmeliorIA

tekio.org

Exemple de code : Désapprentissage

Ce que le dossier 10-desapprentissage/ fournit pour cette méthode. Principe et références : Désapprentissage.

Ce que fait l'exemple

  1. Génère 40 personnages (160 questions). Tire 4 personnages à oublier.
  2. Implantation : SFT sur toutes les questions. Le modèle connaît alors les 40 personnages.
  3. Mesure oubli, retenu et perplexite_generale.
  4. 60 pas de NPO + rétention.
  5. Remesure. Attendu : l'exactitude sur les 4 personnages oubliés chute, celle sur les 36 autres et la perplexité générale restent proches.

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-0.5B-Instruct<br/>wikitext-2"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>génère les personnages<br/>boucle NPO"]
    TRL["TRL SFTTrainer<br/>implantation"]
    Ev["mesurer()<br/>evaluation.py"]
  end
  GPU["GPU CUDA, 12 Go"]
  Out[("sorties/<br/>10-desapprentissage/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids (1 Go), textes" --> Cache
  Cache -- "② lecture des poids" --> Run
  Run -- "④ appel Python<br/>trainer.train()" --> TRL
  TRL -- "⑤ noyaux CUDA<br/>forward, backward" --> GPU
  Run -- "⑥ ⑨ appel Python<br/>mesure avant, après" --> Ev
  Ev -- "⑦ ⑩ noyaux CUDA<br/>génération, forward" --> GPU
  Run -- "③ copie des poids<br/>⑧ NPO, forward, backward" --> GPU
  Run -- "⑪ ⑫ écriture" --> Out
  GPU ~~~ Out

  class Hub externe
  class Run,TRL,Ev code
  class GPU gpu
  class Cache,Out disque

make run EX=EDIT10 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, données, implantation, désapprentissage, évaluation) et génère en mémoire, sans téléchargement, 40 personnages fictifs aux noms inventés, avec 4 questions chacun (ville, année de naissance, métier, création) : 160 questions. 10 % des personnages, soit 4 personnages et 16 questions, sont tirés pour être oubliés ; les 144 autres questions sont à retenir.

  • ① Téléchargement. Au premier lancement, transformers télécharge les poids de Qwen2.5-0.5B-Instruct (environ 1 Go, safetensors) depuis le Hugging Face Hub, par HTTPS. À la première mesure, la bibliothèque datasets télécharge aussi wikitext-2, qui sert à la perplexité générale.
  • ② Lecture. Poids et textes 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 fp32 dans la mémoire du GPU, où ils restent jusqu'à la fin.
  • ④ Implantation. Le modèle ne connaît pas les personnages inventés : run.py les lui apprend d'abord avec le SFTTrainer de TRL, sur les 160 questions, pendant 8 époques (lots de 8, accumulation 2, taux d'apprentissage 2e-5). Tous les poids sont entraînés.
  • ⑤ Forward et backward sur le GPU. La perte porte sur la réponse seulement, pas sur la question. Le gradient checkpointing recalcule les activations pendant la passe arrière au lieu de les garder.
  • ⑥ Mesure avant. run.py mesure trois choses : la vraisemblance des bonnes réponses (nll_oubli, nll_retenu), l'exactitude en génération sur les 16 questions à oublier et sur 80 questions retenues, et la perplexité sur 40 paragraphes du split test de wikitext-2.
  • ⑦ Génération et passes avant sur le GPU. Chaque réponse est générée jusqu'à 24 tokens, par lots de 16 ; elle est juste si elle contient la réponse attendue. La vraisemblance et la perplexité ne demandent qu'une passe avant par lot.
  • ⑧ Désapprentissage NPO. La boucle est écrite dans run.py, sans Trainer : 60 pas, lots de 8, AdamW au taux 1e-5, gradients bornés à 1. À chaque pas, un lot de questions à oublier reçoit la perte NPO (β = 0,1), qui pousse la probabilité des bonnes réponses sous celle d'une copie figée du modèle, prise juste après l'implantation. Un lot de questions retenues ajoute la perte habituelle, de poids 1, pour garder le reste.
  • ⑨ Mesure après. Les mêmes questions et les mêmes paragraphes sont mesurés sur le modèle modifié.
  • ⑩ Génération et passes avant sur le GPU, avec le même décodage qu'en ⑦.
  • ⑪ Écriture du modèle dans sorties/10-desapprentissage/modele-npo/.
  • ⑫ Écriture du rapport dans sorties/10-desapprentissage/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. 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. En entraînement (⑤, ⑧), chaque pas fait une passe avant, une passe arrière qui calcule les gradients de tous les poids, puis la mise à jour par AdamW, dont l'état couvre tout le modèle. Les poids maîtres restent en fp32, les calculs se font en bf16. Pendant ⑧, le GPU porte aussi la copie de référence de NPO, en bf16 et sans gradients : pour chaque lot à oublier, elle fait une passe avant de plus.

Ce qui est écrit.

Fichier Contenu
modele-npo/model.safetensors Le modèle complet après implantation puis désapprentissage (1,9 Go, en fp32)
modele-npo/config.json, generation_config.json L'architecture et les réglages de génération, pour recharger le modèle avec AutoModelForCausalLM.from_pretrained
modele-npo/tokenizer.json, tokenizer_config.json, chat_template.jinja Le tokenizer et le format de conversation, copiés pour que le dossier se suffise à lui-même
implantation/ Dossier de travail du SFTTrainer, vide : aucun point de contrôle n'est sauvegardé
resultats.json Pour avant et apres : nll_oubli, nll_retenu, perplexite_generale, et l'exactitude oubli et retenu avec trois réponses d'exemple ; la liste entites_oubliees des 4 personnages oubliés
config_effective.yaml La configuration réellement utilisée, surcharges SET comprises

Avec SET="sauvegarder=false", le dossier modele-npo/ n'est pas écrit. Avec une autre méthode (desapprentissage.methode), il prend son nom : modele-gradient_ascent/, modele-idk/...

Essayer dans le dépôt

Exemple Statut Résultat mesuré Durée Commande
exemple principal démontré oubli 1,0 → 0,0 ; rétention 1,0 → 0,925 ; perplexité 25,8 → 26,6 test : 20 s
complet : 59 s
make test EX=EDIT10
non testé version grosse infra jamais exécutée 10-desapprentissage/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=EDIT10
make run EX=EDIT10

Utilisation

python run.py --quick
python run.py                                                          # NPO + rétention, Qwen2.5-0.5B, 40 personnages, 10 % oubliés
python run.py --set desapprentissage.methode=gradient_ascent           # observer l'effondrement de `retenu`
python run.py --set desapprentissage.methode=gradient_difference
python run.py --set desapprentissage.methode=idk
python run.py --set donnees.part_oubli=0.05 --set entrainement.max_steps=120
python run.py --set donnees.source=tofu --set implantation.activer=false --set modele.nom=open-unlearning/tofu_Llama-3.2-1B-Instruct_full

Paramètres principaux

Clé Rôle
desapprentissage.methode Voir le tableau
desapprentissage.beta NPO : plus grand = arrêt plus précoce
desapprentissage.poids_retenu Équilibre entre oubli et rétention
entrainement.max_steps, lr Trop de pas, et tout s'effondre (surtout en gradient ascent)
donnees.source faits (généré) ou tofu (benchmark réel)

Grosse infra

  • infra/config.yaml : TOFU forget10 sur le modèle Llama-3.1-8B déjà fine-tuné sur TOFU (1 GPU 80 Go).
  • infra/lancer.sh : open-unlearning, le cadre de référence. Benchmarks TOFU, MUSE, WMDP ; méthodes GradAscent, GradDiff, NPO, SimNPO, DPO, RMU ; multi-GPU via accelerate/DeepSpeed ; métriques standard (forget quality, model utility, attaques par extraction).