Comment créer votre propre RAG avec des modèles LLM gratuits et une base de connaissances

Cet article explore la mise en œuvre d'un système de questions-réponses simple mais efficace qui combine des modèles modernes basés sur des transformateurs. Le système utilise T5 (Text-to-Text Transfer Transformer) pour la génération de réponses et des transformateurs de phrases pour la correspondance de similarité sémantique.

Dans mon article précédent, j'ai expliqué comment créer une API de traduction simple avec une interface Web à l'aide d'un modèle LLM fondamental gratuit. Cette fois, plongeons-nous dans la création d'un système de génération de récupération augmentée (RAG) à l'aide de modèles LLM gratuits basés sur des transformateurs et d'une base de connaissances.

RAG (Retrieval-Augmented Generation) est une technique qui combine deux éléments clés :

Récupération : Tout d'abord, il recherche dans une base de connaissances (comme des documents, des bases de données, etc.) pour trouver des informations pertinentes pour une requête donnée. Cela implique généralement :

• Conversion du texte en intégrations (vecteurs numériques qui représentent le sens)
• Trouver du contenu similaire à l'aide de mesures de similarité (comme la similarité cosinus)
• Sélectionner les informations les plus pertinentes

Génération : Ensuite, il utilise un modèle de langage (comme T5 dans notre code) pour générer une réponse par :

Combiner les informations récupérées avec la question d'origine

Créer une réponse en langage naturel basée sur ce contexte

Dans le code :

• Le SentenceTransformer gère la partie récupération en créant des intégrations
• Le modèle T5 gère la partie génération en créant des réponses

Avantages du RAG :

• Des réponses plus précises car fondées sur des connaissances spécifiques
• Hallucinations réduites par rapport aux réponses LLM pures
• Possibilité d'accéder à des informations à jour ou spécifiques au domaine
• Plus contrôlable et transparent que la génération pure

Présentation de l'architecture du système

L'implémentation consiste en une classe SimpleQASystem qui orchestre deux composants principaux :

• Un système de recherche sémantique utilisant Sentence Transformers
• Un système de génération de réponses utilisant T5

Vous pouvez télécharger la dernière version du code source ici : https://github.com/alexander-uspenskiy/rag_project

Diagramme du système

Guide de configuration du projet RAG

Ce guide vous aidera à configurer votre projet Retrieval-Augmented Generation (RAG) sur macOS et Windows.

Conditions préalables

Pour macOS :

Installer Homebrew (s'il n'est pas déjà installé) :
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Installez Python 3.8 en utilisant Homebrew
brasser installer python@3.10
Pour Windows :
Téléchargez et installez Python 3.8 depuis python.org
Assurez-vous de cocher « Ajouter Python au PATH » lors de l'installation

Configuration du projet

Étape 1 : Créer un répertoire de projet

macOS :

mkdir RAG_project
cd RAG_project
Windows :

mkdir RAG_project
cd RAG_project

Étape 2 : configurer l'environnement virtuel

macOS :

python3 -m venv venv
source venv/bin/activate

Windows :

python -m venv venv
venvScriptsactivate

**Composants de base

1. Initialisation**

def __init__(self):
    self.model_name = 't5-small'
    self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
    self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
    self.encoder = SentenceTransformer('paraphrase-MiniLM-L6-v2')

Le système s'initialise avec deux modèles principaux :

T5-small : Une version plus petite du modèle T5 pour générer des réponses
paraphrase-MiniLM-L6-v2 : Un modèle de transformateur de phrases pour encoder du texte en vecteurs significatifs

2. Préparation de l'ensemble de données

def prepare_dataset(self, data: List[Dict[str, str]]):
    self.answers = [item['answer'] for item in data]
    self.answer_embeddings = []
    for answer in self.answers:
        embedding = self.encoder.encode(answer, convert_to_tensor=True)
        self.answer_embeddings.append(embedding)

La phase de préparation du jeu de données :

• Extrait les réponses des données d'entrée
• Crée des intégrations pour chaque réponse à l'aide du transformateur de phrase
• Stocke les deux réponses et leurs intégrations pour une récupération rapide

Comment fonctionne le système

1. Traitement des questions

Lorsqu'un utilisateur soumet une question, le système suit ces étapes :

Génération d'intégration : la question est convertie en représentation vectorielle en utilisant le même modèle de transformateur de phrase que celui utilisé pour les réponses.

Recherche sémantique : le système trouve la réponse stockée la plus pertinente par :

• Calcul de la similarité cosinus entre l'intégration de questions et toutes les intégrations de réponses
• Sélection de la réponse avec le score de similarité le plus élevé Formation du contexte : la réponse sélectionnée devient le contexte permettant à T5 de générer une réponse finale.

2. Génération de réponses

def get_answer(self, question: str) -> str:
    # ... semantic search logic ...
    input_text = f"Given the context, what is the answer to the question: {question} Context: {context}"
    input_ids = self.tokenizer(input_text, max_length=512, truncation=True, 
                             padding='max_length', return_tensors='pt').input_ids
    outputs = self.model.generate(input_ids, max_length=50, num_beams=4, 
                                early_stopping=True, no_repeat_ngram_size=2

Le processus de génération de réponses :

• Combine la question et le contexte dans une invite pour T5
• Tokenise le texte saisi avec une longueur maximale de 512 jetons
• Génère une réponse à l'aide de la recherche de faisceau avec ces paramètres :
• max_length=50 : Limite la longueur des réponses
• num_beams=4 : utilise la recherche de faisceaux avec 4 faisceaux
• early_stopping=True : arrête la génération lorsque tous les faisceaux atteignent un jeton de fin
• no_repeat_ngram_size=2 : empêche la répétition des bigrammes

3. Réponse Nettoyage

def __init__(self):
    self.model_name = 't5-small'
    self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
    self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
    self.encoder = SentenceTransformer('paraphrase-MiniLM-L6-v2')

• Supprime les mots consécutifs en double (insensible à la casse)
• Mise en majuscule la première lettre de la réponse
• Supprime les espaces supplémentaires

Code source complet

Vous pouvez télécharger la dernière version du code source ici : https://github.com/alexander-uspenskiy/rag_project

def prepare_dataset(self, data: List[Dict[str, str]]):
    self.answers = [item['answer'] for item in data]
    self.answer_embeddings = []
    for answer in self.answers:
        embedding = self.encoder.encode(answer, convert_to_tensor=True)
        self.answer_embeddings.append(embedding)

Gestion de la mémoire :

Le système utilise explicitement le processeur pour éviter les problèmes de mémoire
Les intégrations sont converties en tenseurs CPU si nécessaire
La longueur d'entrée est limitée à 512 jetons

Gestion des erreurs :

• Blocs try-sauf complets dans tout le code
• Messages d'erreur significatifs pour le débogage
• Contrôles de validation pour les composants non initialisés

Exemple d'utilisation

def get_answer(self, question: str) -> str:
    # ... semantic search logic ...
    input_text = f"Given the context, what is the answer to the question: {question} Context: {context}"
    input_ids = self.tokenizer(input_text, max_length=512, truncation=True, 
                             padding='max_length', return_tensors='pt').input_ids
    outputs = self.model.generate(input_ids, max_length=50, num_beams=4, 
                                early_stopping=True, no_repeat_ngram_size=2

Exécuter dans le terminal

Limites et améliorations potentielles

Évolutivité :

L'implémentation actuelle conserve toutes les intégrations en mémoire
Pourrait être amélioré avec des bases de données vectorielles pour des applications à grande échelle

Qualité des réponses :

S'appuie fortement sur la qualité de l'ensemble de données de réponses fourni
Limité par la fenêtre contextuelle de T5-small
Pourrait bénéficier d'une validation des réponses ou d'un score de confiance

Performances :

• L'utilisation du processeur uniquement peut être plus lente pour les applications à grande échelle
• Pourrait être optimisé avec le traitement par lots
• Pourrait implémenter la mise en cache pour les questions fréquemment posées

Conclusion

Cette implémentation fournit une base solide pour un système de questions-réponses, combinant les atouts de la recherche sémantique et de la génération de texte basée sur un transformateur. N'hésitez pas à jouer avec les paramètres du modèle (comme max_length, num_beams, early_stopping, no_repeat_ngram_size, etc.) pour trouver un meilleur moyen d'obtenir des réponses plus cohérentes et stables. Bien qu'il y ait place à l'amélioration, la mise en œuvre actuelle offre un bon équilibre entre complexité et fonctionnalité, ce qui la rend adaptée aux fins éducatives et aux applications à petite et moyenne échelle.

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!