AmeliorIA

tekio.org

Exemple de code : RAG

Ce que le dossier 18-rag/ fournit pour cette méthode. Principe et références : RAG.

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/>LLM, encodeurs<br/>wikitext-2"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>corpus, fusion RRF<br/>assemblage du prompt"]
    BM["BM25"]
    Enc["sentence-transformers<br/>mpnet, cross-encoder"]
    Gen["generateur.py<br/>chat()"]
  end
  GPU["GPU CUDA, 12 Go"]
  API["serveur d'API<br/>Ollama, vLLM…"]
  Out[("sorties/18-rag/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids, wikitext-2" --> Cache
  Cache -- "② lecture des poids<br/>et des textes" --> Run
  Run -- "③ ⑥ calcul CPU<br/>BM25" --> BM
  Run -- "④ ⑦ appel Python<br/>encode, predict" --> Enc
  Enc -- "⑤ ⑧ noyaux CUDA<br/>embeddings" --> GPU
  Run -- "⑨ copie des poids<br/>en mémoire GPU" --> GPU
  Run -- "⑩ ⑫ appel Python<br/>sans RAG, avec RAG" --> Gen
  Gen -- "⑪ ⑬ noyaux CUDA<br/>génération" --> GPU
  Gen -. "⑪' ⑬' HTTP POST<br/>/v1/chat/completions" .-> API
  Run -- "⑭ écriture" --> Out
  GPU ~~~ Out
  GPU ~~~ API

  class Hub,API externe
  class Run,BM,Enc,Gen code
  class GPU gpu
  class Cache,Out disque

make run EX=EXEC18 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, méthode de recherche, encodeur, reranker, gabarit du prompt, taille du corpus) et construit le corpus : 50 personnages inventés, générés en mémoire, décrits chacun par 4 fiches (200 passages), noyés parmi 2 000 paragraphes Wikipédia sans rapport, tirés de wikitext-2 (2 200 passages au total). Les 200 questions portent sur ces personnages : le modèle ne peut pas connaître les réponses. Aucun poids n'est modifié. Le modèle est chargé en local par défaut ; avec make run EX=EXEC18 API=http://localhost:11434/v1 MODELE=qwen3:8b, il est servi par une API compatible OpenAI.

  • ① Téléchargement. Au premier lancement, le jeu Salesforce/wikitext, l'encodeur all-mpnet-base-v2, le reranker ms-marco-MiniLM-L-6-v2 et le LLM Qwen2.5-1.5B-Instruct 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. Chaque modèle est lu au moment où il est chargé (④, ⑨).
  • ③ Index lexical. run.py découpe les 2 200 passages en mots et calcule, sur le CPU, les statistiques de BM25 : fréquence de chaque mot dans chaque passage, rareté de chaque mot dans le corpus.
  • ④ Index dense. sentence-transformers charge all-mpnet-base-v2 et encode les 2 200 passages, par lots de 64 ; il charge aussi le cross-encoder qui servira au reranking.
  • ⑤ Embeddings sur le GPU. Chaque passage devient un vecteur normalisé, gardé en mémoire GPU.
  • ⑥ Recherche lexicale. Pour chaque question, BM25 renvoie les 20 passages les mieux notés.
  • ⑦ Recherche dense et reranking. La question est encodée et comparée aux 2 200 vecteurs (similarité cosinus) : 20 autres candidats. Les deux listes sont fusionnées par rang (Reciprocal Rank Fusion, constante 60), puis le cross-encoder note chaque couple question-passage ; les 3 meilleurs passages sont gardés. Le rappel mesure la part des questions dont au moins un de ces 3 passages parle du bon personnage.
  • ⑧ Embeddings et reranking sur le GPU : encodage de la question, puis une passe avant du cross-encoder par couple question-passage.
  • ⑨ Copie du LLM sur le GPU. commun/generateur.py charge Qwen2.5-1.5B-Instruct avec transformers et copie ses poids en bf16 dans la mémoire du GPU. En mode API, cette étape n'a pas lieu.
  • ⑩ Mesure sans RAG. Les 200 questions sont posées seules, suivies de « Answer briefly. ».
  • ⑪ Génération sur le GPU. Par lots de 16, en décodage glouton, jusqu'à 32 tokens. Une réponse est juste si elle contient la valeur 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 ⑪ et ⑬ ; c'est le serveur qui génère.
  • ⑫ Mesure avec RAG. Chaque question est placée dans le gabarit de config.yaml, avec les 3 passages retrouvés numérotés [1] à [3] et la consigne de répondre seulement à partir de ce contexte.
  • ⑬ Génération sur le GPU, avec le même décodage qu'en ⑪.
  • ⑭ Écriture du rapport dans sorties/18-rag/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. L'encodeur et le cross-encoder (⑤, ⑧) font une passe avant par texte ou par couple question-passage, sans génération. Le LLM (⑪, ⑬) fait une passe avant par token produit, accélérée par un cache des clés et des valeurs déjà calculées. BM25 et la fusion RRF tournent sur le CPU. En mode API, le GPU local ne sert plus au LLM : c'est le serveur qui génère, et seuls l'encodeur et le reranker tournent encore sur la machine.

Ce qui est écrit.

Fichier Contenu
resultats.json Exactitude sans RAG et avec RAG, début de la première réponse de chaque côté, rappel à 3 de la recherche, méthode de recherche utilisée (hybride + reranker)
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é exactitude 0 → 1,0 ; rappel@3 = 1,0 test : 14 s
complet : 54 s
make test EX=EXEC18
non testé version grosse infra jamais exécutée 18-rag/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=EXEC18
make run EX=EXEC18

Utilisation

python run.py --quick
python run.py                                                   # hybride + reranker, Qwen2.5-1.5B-Instruct
python run.py --set recherche.methode=bm25 --set recherche.reranker=null
python run.py --set recherche.methode=dense
python run.py --set recherche.k=1                               # moins de contexte : observer rappel et exactitude
python run.py --set modele.api_base=http://localhost:11434/v1 --set modele.nom=qwen3:8b

Paramètres principaux

Clé Rôle
recherche.methode bm25, dense ou hybride
recherche.embeddings, reranker Modèles de recherche (bge-m3 / bge-reranker-v2-m3 pour le français)
recherche.k, k_candidats Passages fournis / récupérés avant reranking
gabarit Consigne et format du prompt
donnees.n_distracteurs Difficulté de la recherche

Grosse infra

  • infra/docker-compose.yml : pile de production. Qdrant (base vectorielle), TEI (embeddings bge-m3 et reranker sur GPU), vLLM (Qwen2.5-72B-AWQ sur 2 GPU).
  • infra/indexer_qdrant.py : découpage avec chevauchement, embeddings par lots, insertion.
  • infra/interroger.py : recherche → reranking → réponse avec citations [n].
  • infra/config.yaml : run.py contre ce LLM servi, avec 500 personnages et 20 000 distracteurs.
  • Au-delà : recherche multi-vecteurs (ColBERT), graphes de connaissances (GraphRAG), RAG agentique (le modèle décide quoi chercher : EXEC19), fine-tuning des embeddings sur ses propres paires question/passage.