RAG et embeddings : comprendre et implémenter

Le RAG (Retrieval-Augmented Generation) est une technique révolutionnaire qui combine la récupération d'informations et la génération de texte pour améliorer la précision des modèles de langage (LLM). Les embeddings jouent un rôle central dans le RAG en permettant de représenter les mots, phrases et documents sous forme de vecteurs numériques. Cela permet aux modèles d'IA de comprendre le sens et les relations entre les concepts.

Pourquoi cet article ?

• Comprendre le fonctionnement du RAG et son utilité.
• Découvrir le rôle des embeddings dans le RAG.
• Apprendre à implémenter le RAG avec des exemples concrets.

⭐ Difficulté : ★★★☆☆ (3/5)

✅ Pédagogique : Analogies visuelles, exemples concrets, et schémas explicites.
⚠️ Technique : Concepts avancés (embeddings, similarité cosinus, bases vectorielles) et manipulation de bibliothèques Python (Sentence Transformers, FAISS, LangChain).
🔍 Vocabulaire : Termes comme *chunking*, *vector store*, *retriever*, *similarité cosinus*, ou *fine-tuning* nécessitent des bases en IA et en traitement des données.

📚 Prérequis recommandés

📊 Statistiques/NLP : Notions de vecteurs, distances, et traitement du langage naturel.
💻 Python intermédiaire : Manipulation de bibliothèques (LangChain, FAISS, Hugging Face).
🗃️ Gestion de données : Prétraitement de texte, segmentation, et stockage vectoriel.
🖥️ Environnement technique : Accès à un LLM (local ou API), Ollama installé, GPU recommandé.

Un embedding est une technique qui permet de représenter des mots, des phrases ou des documents sous forme de vecteurs numériques. Ces vecteurs capturent le sens et les relations entre les éléments qu'ils représentent.

Imaginez que chaque mot est une étoile dans l'espace. Les embeddings sont comme des coordonnées qui placent chaque étoile (mot) de manière à ce que :

• Les étoiles proches ont des sens similaires.
• Les étoiles éloignées ont des sens différents.

Exemple :

• Le mot “roi” sera proche de “reine” et “prince”.
• Le mot “pomme” sera proche de “fruit” et “banane”, mais éloigné de “roi”.

Les ordinateurs ne comprennent pas les mots directement. Ils ont besoin de nombres pour traiter l'information. Les embeddings permettent de :

• Transformer du texte en nombres que les modèles d'IA peuvent comprendre.
• Capturer le sens et les relations entre les mots (ex. : “roi” - “reine” ≈ “homme” - “femme”).
• Réduire la dimension des données pour les rendre plus faciles à manipuler.

Voici un exemple de mots et leurs embeddings (simplifiés en 2D) :

Observations :

• “roi” et “reine” sont proches (sens similaire).
• “homme” et “femme” sont proches de “roi” et “reine” (relations de genre).
• “pomme” et “banane” sont proches (tous deux des fruits), mais éloignés des mots liés à la royauté.

          reine (0.3, 0.7)
            /
           /
roi (0.2, 0.8)
           \
            \
          homme (0.25, 0.75)

pomme (-0.1, 0.1) ------------------- banane (-0.2, 0.2)

Chaque mot est d'abord représenté par un identifiant unique (ex. : un nombre). Par exemple :

• “roi” → 1
• “reine” → 2
• “pomme” → 3

Mais cette représentation ne capture aucun sens !

Les embeddings transforment chaque mot en un vecteur (une liste de nombres). Par exemple :

• “roi” → [0.2, 0.8, -0.5, 0.1, …]
• “reine” → [0.3, 0.7, -0.4, 0.2, …]
• “pomme” → [-0.1, 0.1, 0.9, -0.3, …]

Ces vecteurs sont appris par des modèles d'IA (comme Word2Vec, GloVe, ou BERT) de manière à ce que :

• Les mots similaires aient des vecteurs proches.
• Les mots différents aient des vecteurs éloignés.

On peut visualiser ces vecteurs dans un espace à 2 ou 3 dimensions (même si en réalité, ils ont souvent 50 à 300 dimensions).

Exemple visuel :

        reine (0.3, 0.7)
          /
         /
roi (0.2, 0.8)
         \
          \
        homme (0.25, 0.75)

pomme (-0.1, 0.1) ------------------- banane (-0.2, 0.2)

Le RAG est une technique qui combine :

• La récupération d'informations (retrieval) à partir d'une base de données.
• La génération de texte (generation) par un modèle de langage (LLM).

Pourquoi le RAG ?

• Précision : Réduit les hallucinations des LLM en s'appuyant sur des données externes.
• Actualité : Permet d'utiliser des informations récentes ou spécifiques à un domaine.
• Transparence : Les sources utilisées peuvent être citées, améliorant la confiance dans les réponses.

• Objectif : Préparer une base de données de documents pour la recherche.
• Processus :

1. Les documents sont découpés en morceaux (chunks).
2. Chaque chunk est transformé en un vecteur d'embedding à l'aide d'un modèle (ex. : Sentence-BERT).
3. Les vecteurs sont stockés dans une base de données vectorielle (ex. : FAISS, Chroma, Weaviate).

Exemple :

• Document : “Le RAG est une technique qui combine la récupération d'informations et la génération de texte.”
• Chunk : “Le RAG est une technique qui combine la récupération d'informations.”
• Embedding :

  [0.12, 0.45, -0.23, 0.67, ...]

  (vecteur numérique).

Schéma :

+---------------------+       +---------------------+       +---------------------+
|   Documents         | ----> |   Découpage en      | ----> |  Embeddings         |
| (ex: PDF, texte)    |       |   chunks            |       |(vecteurs numériques)|
+---------------------+       +---------------------+       +---------------------+
                                                                      |
                                                                      v
                                                            +---------------------+
                                                            |   Base de données   |
                                                            |   vectorielle       |
                                                            +---------------------+

• Objectif : Trouver les chunks les plus pertinents pour répondre à une requête.
• Processus :

1. La requête de l'utilisateur est transformée en un vecteur d'embedding.
2. La base de données vectorielle compare le vecteur de la requête avec les vecteurs des chunks.
3. Les chunks les plus proches (en termes de similarité cosinus) sont sélectionnés.

Exemple :

• Requête : “Qu'est-ce que le RAG ?”
• Embedding de la requête :

  [0.15, 0.40, -0.25, 0.70, ...]

• Chunks récupérés : Les 3 chunks dont les embeddings sont les plus proches de celui de la requête.

Schéma :

+---------------------+       +---------------------+       +---------------------+
|   Requête           | ----> |   Embedding de la   | ----> |   Recherche des     |
| (ex: "Qu'est-ce     |       |   requête           |       |   chunks similaires |
|  que le RAG ?")     |       |                     |       |                     |
+---------------------+       +---------------------+       +---------------------+
                                                               |
                                                               v
                                                            +---------------------+
                                                            |   Chunks pertinents |
                                                            |   (ex: 3 chunks)    |
                                                            +---------------------+

• Objectif : Générer une réponse précise en utilisant les chunks récupérés.
• Processus :

1. Les chunks récupérés sont ajoutés au prompt du modèle de langage.
2. Le modèle de langage (ex. : Llama, GPT) génère une réponse en se basant sur les chunks et la requête.

Exemple de prompt :

Réponds à la question en utilisant uniquement les informations suivantes :
---
Chunk 1 : "Le RAG est une technique qui combine la récupération d'informations..."
Chunk 2 : "Il utilise des embeddings pour représenter les documents..."
Chunk 3 : "Le RAG améliore la précision des modèles de langage..."
---
Question : Qu'est-ce que le RAG ?

Schéma :

+---------------------+       +---------------------+       +---------------------+
|   Chunks pertinents | ----> | Prompt pour le LLM  | ----> |   Réponse générée   |
|                     |       |(incluant les chunks)|       |                     |
+---------------------+       +---------------------+       +---------------------+

Les embeddings permettent de :

1. Transformer du texte en nombres : Les modèles d'IA ne comprennent pas le texte brut, mais ils peuvent traiter des vecteurs numériques.
2. Capturer le sens et les relations : Les embeddings placent les mots et phrases similaires proches les uns des autres dans l'espace vectoriel.
3. Effectuer des recherches rapides : Les bases de données vectorielles (comme FAISS) permettent de trouver rapidement les chunks les plus pertinents.

Exemple concret :

• Requête : “Comment fonctionne le RAG ?”
• Embedding de la requête :

  [0.15, 0.40, -0.25, 0.70, ...]

• Chunks similaires :
  • “Le RAG combine la récupération d'informations et la génération de texte.”

    [0.12, 0.45, -0.23, 0.67, ...]

  • “Les embeddings sont utilisés pour représenter les documents.”

    [0.14, 0.38, -0.27, 0.72, ...]

Voici un exemple complet en Python pour illustrer le lien entre RAG et embeddings :

pip install sentence-transformers faiss-cpu langchain openai

indexation.py

from sentence_transformers import SentenceTransformer
from langchain.vectorstores import FAISS
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import TextLoader
 
# Charger les documents
loader = TextLoader("document.txt")
documents = loader.load()
 
# Découper les documents en chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
docs = text_splitter.split_documents(documents)
 
# Générer les embeddings et créer la base vectorielle
model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode([doc.page_content for doc in docs])
vector_store = FAISS.from_documents(docs, embeddings)

recuperation-regeneration.py

from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
 
# Configurer le LLM
llm = OpenAI(temperature=0)
 
# Créer la chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vector_store.as_retriever()
)
 
# Poser une question
query = "Qu'est-ce que le RAG ?"
response = qa_chain.run(query)
print("Réponse :", response)

Pré-requis : Ollama doit être acti sur votre machine. Si celui-ci n'est pas installé reportez vous aux articles :

• Installation d'Ollama sous Ubuntu 25.04
• Installation d'Ollama sous Windows 11

Pour vérifier si Ollama est un service actif :

systemctl status Ollama

Installez dans Mozilla Firefox l'extension Page Assist

Intégrer un modèle multilingue en allant sur le site Ollama : Modèles LLM - Embeding

Choisir bge-m3

Puisque l'on utilise Page Assis, il nous suffit de cliquer sur le lien de téléchargement comme indiquer ci-dessous :

• Exemple : Un chatbot pour le support client qui utilise une base de connaissances interne.
• Avantage : Réponses précises et basées sur les documents de l'entreprise.

• Exemple : Un moteur de recherche interne pour les employés.
• Avantage : Permet de trouver des informations spécifiques dans une grande base de documents.

• Exemple : Génération de rapports ou de résumés à partir de documents techniques.
• Avantage : Contenu généré basé sur des sources fiables.

Les embeddings sont au cœur du RAG :

• Ils transforment le texte en vecteurs numériques que les modèles d'IA peuvent comprendre.
• Ils permettent de trouver les informations pertinentes dans une base de données.
• Ils améliorent la précision et la pertinence des réponses générées par les LLM.

• Pinecone – Guide RAG
• Sentence Transformers – Embeddings
• GitHub – FAISS
• GitHub – Chroma
• Weaviate – Base vectorielle
• Ollama – Modèles d’embeddings