AmeliorIA

tekio.org

Exemple de code : Calcul à l'inférence

Ce que le dossier 20-calcul-inference/ fournit pour cette méthode. Principe et références : Calcul à l'inférence.

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, GSM8K<br/>Skywork-Reward-V2"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>vote, best-of-N<br/>auto-correction"]
    Gen["generateur.py<br/>chat()"]
    RM["modèle de récompense<br/>Skywork 0,6B"]
  end
  GPU["GPU CUDA, 12 Go"]
  API["Serveur compatible OpenAI<br/>Ollama, vLLM…"]
  Out[("sorties/20-calcul-inference/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids, GSM8K" --> Cache
  Cache -- "② lecture des poids<br/>et des données" --> Run
  Run -- "③ copie des poids<br/>en mémoire GPU<br/>⑧ log-probabilités" --> 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/>notation" --> RM
  RM -- "⑩ noyaux CUDA<br/>passe avant" --> GPU
  Run -- "⑬ écriture<br/>resultats.json" --> Out

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

make run EX=EXEC20 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, stratégies, nombre d'échantillons, température, modèle de récompense, données) et charge 100 problèmes du test de GSM8K depuis le Hugging Face Hub. Toutes les stratégies partagent les mêmes 16 échantillons par question, pour être comparées à coût égal. Aucun poids n'est modifié. Le modèle est chargé en local par défaut ; avec make run EX=EXEC20 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-1.5B-Instruct et du modèle de récompense Skywork-Reward-V2-Qwen3-0.6B, ainsi que le jeu openai/gsm8k, 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.
  • ④ Référence gloutonne. run.py pose les 100 problèmes, suivis de « Think step by step and end with 'Answer: '. ».
  • ⑤ Génération sur le GPU. Par lots de 16, en décodage glouton, jusqu'à 384 tokens : 100 générations.
  • ⑤' 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 ⑤, ⑦ et ⑫ ; c'est le serveur qui génère. Si le serveur ignore le paramètre n (Ollama), les échantillons sont demandés par appels successifs.
  • ⑥ Échantillonnage. Les mêmes problèmes sont reposés avec 16 réponses par question, à température 0,8.
  • ⑦ Génération sur le GPU : 1 600 générations. Sur ces échantillons, run.py calcule sur le CPU le vote majoritaire (le nombre final le plus fréquent) pour N = 1, 2, 4, 8 et 16, et la borne oracle : au moins un des 16 échantillons est juste.
  • ⑧ Best-of-N par vraisemblance. Pour chaque échantillon, une passe avant du LLM calcule la log-probabilité de la réponse sachant la question ; l'échantillon de meilleure log-probabilité moyenne par token est retenu. Cette stratégie demande les poids en local : elle est sautée en mode API.
  • ⑨ Best-of-N par modèle de récompense. run.py charge Skywork-Reward-V2-Qwen3-0.6B, qui donne un score à chaque couple question-réponse ; l'échantillon le mieux noté est retenu.
  • ⑩ Notation sur le GPU : une passe avant du modèle de récompense par question, sur ses 16 échantillons, textes coupés à 1 024 tokens. Ce modèle tourne sur le GPU local, y compris en mode API.
  • ⑪ Auto-correction. Chaque réponse gloutonne est renvoyée au modèle avec la consigne de vérifier chaque étape et de corriger l'erreur s'il y en a une, en 1 tour.
  • ⑫ Génération sur le GPU, avec le même décodage qu'en ⑤ : 100 générations de plus.
  • ⑬ Écriture du rapport dans sorties/20-calcul-inference/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 ; en ⑦, chaque lot de 16 questions produit 256 réponses en parallèle. Le calcul des log-probabilités (⑧) et la notation (⑩) font une seule passe avant sur un texte déjà écrit, sans génération. En mode API, le GPU local ne sert plus au LLM : c'est le serveur qui génère, et seul le modèle de récompense tourne encore sur la machine.

Ce qui est écrit.

Fichier Contenu
resultats.json Pour chaque stratégie (glouton, vote majoritaire, best-of-N par vraisemblance, best-of-N par récompense, auto-correction) : exactitude, et nombre de générations pour le glouton, le vote et l'auto-correction ; courbe d'exactitude du vote en fonction de N ; borne oracle pass@16 ; nom du modèle de récompense
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é glouton 0,65 ; vote sur 16 réponses 0,77 ; oracle 0,93 test : 9 s
complet : 10 min
make test EX=EXEC20
non testé version grosse infra jamais exécutée 20-calcul-inference/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=EXEC20
make run EX=EXEC20

Utilisation

python run.py --quick
python run.py                                                   # GSM8K, Qwen2.5-1.5B-Instruct, N=16
python run.py --set n_echantillons=32 --set temperature=1.0
python run.py --set modele_recompense=sorties/05-rl-en-ligne--variantes--modele-recompense/modele --set donnees.source=arith
python run.py --set modele.api_base=http://localhost:8000/v1 --set modele.nom=Qwen/Qwen2.5-7B-Instruct --set "strategies=[vote_majoritaire, auto_correction]"

Paramètres principaux

Clé Rôle
n_echantillons, temperature Budget et diversité
strategies Stratégies évaluées
modele_recompense Pour best_of_n_recompense
tours_correction Passes d'auto-correction

Grosse infra

  • La génération domine : vLLM en parallélisme de données (--data-parallel-size 8, un réplica par GPU) avec cache de préfixe. Les N échantillons d'une même question partagent le prompt.
  • infra/config.yaml : GSM8K complet (1 319 questions), N=64, RM Skywork 8B ; infra/lancer.sh.
  • Recherche guidée par Process Reward Model (note chaque étape : beam search, DVTS) : search-and-learn.