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.pycharge 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,instructionetfew_shot,run.pyconstruit une conversation par message : la consigne (prompts.instruction) pourinstruction, 8 exemples message → intention tirés au hasard pourfew_shot, en tours de dialogue. Il appellechat(), 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_baseest 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.pycharge 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.noms'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.