AmeliorIA

tekio.org

Exemple de code : Optimisation du prompt

Ce que le dossier 17-optimisation-prompt/ fournit pour cette méthode. Principe et références : Optimisation du prompt.

Ce que fait l'exemple

Le besoin : le même routage de messages bancaires vers 77 intentions qu'en DATA02, sans rien entraîner. Jusqu'où va-t-on en ne changeant que le prompt ?

Résultats (Qwen2.5-0.5B-Instruct, RTX 5070 Ti Laptop ; 3 080 messages de test) :

Stratégie Exactitude Écart apparié avec le zéro-shot
zero_shot : la liste des intentions seule 0,229 [0,214 ; 0,244]
instruction : consigne rédigée à la main 0,225 [0,211 ; 0,240] −0,004, non significatif
optimisation : consigne trouvée par OPRO 0,263 [0,248 ; 0,279] +0,035 [+0,023 ; +0,046]
few_shot : 8 exemples au hasard 0,312 [0,296 ; 0,329] +0,083 [+0,067 ; +0,100]
few_shot_similaires : les 8 exemples les plus proches 0,816 [0,802 ; 0,829] +0,587 [+0,569 ; +0,606]
Témoin sans LLM : vote des 8 exemples les plus proches 0,920 [0,910 ; 0,929] +0,691

Pour comparaison, sur les mêmes messages : SFT complet 0,904 (DATA02), LoRA 0,891 (DATA03), encodeur ModernBERT fine-tuné 0,937.

Ce qu'on en retient.

  • La consigne compte peu ici : rédigée ou optimisée, elle ne change l'exactitude que de quelques points. Le modèle sait déjà ce qu'on attend ; ce qui lui manque, c'est de savoir à quoi ressemble chaque intention.
  • Les exemples choisis par similarité changent tout : 0,229 → 0,816, sans entraînement, en montrant au modèle des messages proches avec leur intention. C'est la stratégie de prompt à essayer en premier dès qu'on dispose d'exemples annotés.
  • Mais le témoin montre d'où vient le gain : le simple vote des intentions de ces 8 exemples, sans LLM, fait mieux (0,920). Le gain vient de la recherche des bons exemples, et le petit LLM en perd une partie. Pour une classification pure avec des exemples annotés, un classifieur (voisins, encodeur fine-tuné) est le bon outil ; le prompt d'un LLM se justifie quand la sortie doit être rédigée, ou quand on n'a pas d'exemples.

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, MiniLM<br/>banking77"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>stratégies de prompt<br/>boucle OPRO"]
    Gen["generateur.py<br/>chat()"]
    Emb["SentenceTransformer<br/>all-MiniLM-L6-v2"]
  end
  GPU["GPU CUDA, 12 Go"]
  API["Serveur compatible OpenAI<br/>Ollama, vLLM…"]
  Out[("sorties/17-optimisation-prompt/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids, banking77" --> Cache
  Cache -- "② lecture des poids<br/>et des données" --> Run
  Run -- "③ copie des poids<br/>en mémoire GPU" --> GPU
  Run -- "④ ⑧ ⑩ appel Python<br/>chat()" --> Gen
  Gen -- "⑤ ⑨ ⑪ noyaux CUDA<br/>génération" --> GPU
  Gen -. "⑤' ⑨' ⑪' HTTP POST<br/>/v1/chat/completions" .-> API
  Run -- "⑥ appel Python<br/>voisins()" --> Emb
  Emb -- "⑦ noyaux CUDA<br/>embeddings" --> GPU
  Run -- "⑫ écriture<br/>resultats.json" --> Out

  GPU ~~~ Out
  class Hub,API externe
  class Run,Gen,Emb code
  class GPU gpu
  class Cache,Out disque

make run EX=EXEC17 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, stratégies comparées, nombre d'exemples, réglages de l'optimisation, données). La tâche est celle de DATA02 et DATA03 : router les messages de clients d'une banque vers l'une de 77 intentions (banking77), la liste des intentions figurant dans le message système de toutes les stratégies. Les 10 003 messages d'entraînement donnent 9 803 exemples pour le few-shot et 200 messages de validation, qui servent à choisir ; les 3 080 messages de test servent à confirmer. Aucun poids n'est modifié. Le modèle est chargé en local par défaut ; avec make run EX=EXEC17 API=http://localhost:11434/v1 MODELE=qwen3:8b, il est servi par une API compatible OpenAI.

  • ① Téléchargement. Au premier lancement, les poids de Qwen2.5-0.5B-Instruct et de l'encodeur all-MiniLM-L6-v2, ainsi que le jeu banking77, sont téléchargés depuis le Hugging Face Hub, par HTTPS.
  • ② Lecture. Tout est rangé dans le cache ~/.cache/huggingface ; les lancements suivants le relisent sur le disque, sans réseau.
  • ③ Copie sur le GPU. commun/generateur.py charge le modèle avec transformers et copie ses poids en bf16 dans la mémoire du GPU. En mode API, cette étape n'a pas lieu.
  • ④ Stratégies simples. Pour zero_shot, instruction et few_shot, run.py construit une conversation par message : la consigne (prompts.instruction) pour instruction, 8 exemples message → intention tirés au hasard pour few_shot, en tours de dialogue. Il appelle chat(), d'abord sur la validation, puis sur le test.
  • ⑤ Génération sur le GPU. Les conversations passent par lots de 32 ; le modèle produit au plus 16 tokens en décodage glouton, dont la première ligne doit être l'intention attendue.
  • ⑤' Génération par API. Quand modele.api_base est renseigné, chat() envoie chaque conversation au serveur par HTTP POST sur /v1/chat/completions à la place de ⑤ (de même pour ⑨ et ⑪) ; c'est le serveur qui génère.
  • ⑥ Recherche d'exemples proches. Pour few_shot_similaires, run.py charge all-MiniLM-L6-v2 avec sentence-transformers et encode les 9 803 exemples et les messages à classer.
  • ⑦ Embeddings sur le GPU. Chaque texte devient un vecteur normalisé ; le produit scalaire donne la similarité cosinus, et les 8 exemples les plus proches de chaque message sont retenus. Leurs intentions servent aussi au témoin : un vote majoritaire, sans LLM.
  • ⑧ Few-shot par similarité. Les conversations sont reconstruites avec ces 8 exemples, puis envoyées à chat().
  • ⑨ Génération sur le GPU, avec le même décodage qu'en ⑤.
  • ⑩ Optimisation de l'instruction. Boucle de type OPRO : 4 tours où le modèle lui-même (ou optimiseur.nom s'il est renseigné) reçoit les instructions déjà essayées avec leur score et en propose 4 nouvelles, échantillonnées à température 1,0 ; chaque proposition est notée sur les 200 messages de validation. La meilleure est ensuite mesurée sur le test.
  • ⑪ Génération sur le GPU, pour les propositions comme pour les mesures.
  • ⑫ Écriture du rapport dans sorties/17-optimisation-prompt/resultats.json, avec le même tableau affiché dans le terminal.

Ce que fait le GPU. Il n'y a aucun entraînement : seulement des passes avant. 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. Pour les embeddings (⑦), l'encodeur fait une seule passe avant par texte. En mode API, le GPU local ne sert plus au LLM : c'est le serveur qui génère, et seul l'encodeur de ⑦ tourne encore sur la machine.

Ce qui est écrit.

Fichier Contenu
resultats.json Pour chaque stratégie et pour le témoin des voisins : exactitude en validation et en test, avec intervalle à 95 % et réponse de chaque message ; comparaisons appariées avec le zéro-shot ; stratégie la meilleure en validation ; instruction retenue par l'optimisation ; historique de toutes les instructions essayées avec leur score de validation
config_effective.yaml La configuration réellement utilisée, surcharges SET comprises

Essayer dans le dépôt

Exemple Statut Résultat mesuré Durée Commande
exemple principal démontré intentions : zéro-shot 0,229 ; consigne OPRO 0,263 ; 8 exemples au hasard 0,312 ; 8 exemples les plus proches 0,816 (n = 3 080) — le vote des 8 exemples les plus proches, sans LLM, fait mieux (0,920) test : 18 s
complet : 8 min
make test EX=EXEC17
non testé version grosse infra jamais exécutée 17-optimisation-prompt/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=EXEC17
make run EX=EXEC17

Utilisation

python run.py --quick
python run.py                                                      # 5 stratégies et le témoin, Qwen2.5-0.5B-Instruct, banking77, ~8 min
python run.py --set modele.api_base=http://localhost:11434/v1 --set modele.nom=qwen3:8b       # modèle servi par Ollama
python run.py --set optimiseur.nom=Qwen/Qwen2.5-7B-Instruct         # un optimiseur plus fort
python run.py --set "strategies=[few_shot, few_shot_similaires]" --set k_exemples=4
# Raisonnement mathématique (GSM8K), où la consigne et le raisonnement pas à pas comptent davantage :
python run.py --set donnees.source=gsm8k --set donnees.n_train=500 --set evaluation.mode=nombre \
  --set evaluation.dev_depuis_train=false --set evaluation.n_dev=60 --set evaluation.n_test=200 \
  --set evaluation.max_new_tokens=384 --set evaluation.systeme=null --set k_exemples=4 \
  --set "strategies=[zero_shot, instruction, cot, few_shot, few_shot_similaires, optimisation]" \
  --set "prompts.instruction=Solve the problem. Show the intermediate calculations, then finish with 'Answer: <number>'." \
  --set "optimisation.tache=solve math word problems"

Paramètres principaux

Clé Rôle
modele.nom, modele.api_base Modèle local ou API
optimiseur.* Modèle qui propose des instructions
strategies Stratégies comparées
k_exemples, embeddings Few-shot : nombre d'exemples, encodeur qui trouve les plus proches
prompts.instruction, prompts.cot Consigne de départ, et phrase ajoutée par la stratégie cot
optimisation.tache Description de la tâche donnée à l'optimiseur OPRO
optimisation.tours, candidats Budget de recherche
evaluation.n_dev, n_test, dev_depuis_train Validation (choix) et test (confirmation) ; validation prise dans l'entraînement pour garder le test entier
evaluation.systeme Cadre commun à toutes les stratégies ; {intentions} y est remplacé par la liste des intentions

Grosse infra

  • Rien à entraîner : l'infra sert à servir un gros modèle (vLLM, tensor parallel) et à évaluer beaucoup de candidats en parallèle.
  • infra/config.yaml : Qwen2.5-72B servi sur 4 GPU, GSM8K, 10 tours × 8 candidats.
  • infra/dspy_miprov2.py : DSPy MIPROv2 sur le même modèle servi (32 appels parallèles).
  • infra/lancer.sh : démarrage du serveur, puis les deux optimisations.