Surmontez les hallucinations du LLM grâce aux bases de connaissances

Quoi?

Si vous demandez à un LLM de « suggérer un excellent langage de programmation pour l’apprentissage automatique »

La réponse des LLM serait : « L’un des langages de programmation les plus recommandés pour l’apprentissage automatique est Python. Python est un langage de haut niveau… »

Que faire si vous souhaitez que votre organisation fournisse des informations spécifiques à l'organisation vérifiées, c'est-à-dire qu'elle améliore la réponse avec des informations authentiques sur l'organisation ?

Faisons en sorte que cela se produise lors de l'interaction avec LLM

Pourquoi?

Les LLM les plus populaires, comme chatGPT d'OpenAI ou Gemini de Google, sont formés à partir de données accessibles au public. Ils manquent souvent d'informations spécifiques à l'organisation. Il arrive parfois que les organisations souhaitent s'appuyer sur les LLM. Cependant, elles souhaitent améliorer la réponse spécifique à une organisation particulière ou ajouter des clauses de non-responsabilité lorsqu'aucune donnée de base n'est disponible.

Le processus qui permet d'y parvenir est connu sous le nom de « mise à la terre de la réponse du LLM à l'aide des bases de connaissances ».

Comment?

Pendant ce temps, je peux simplement en parler.

En tant qu'ingénieur, regarder quelques extraits de code me donne confiance.

Les mettre en pratique augmente ma confiance et me procure également du bonheur. Partager me procure de la satisfaction 😄

Du code ? Pourquoi pas ! → Python ? Bien sûr !!

1. Installer les bibliothèques requises

    pip install openai faiss-cpu numpy python-dotenv

• openai : pour interagir avec les modèles et les intégrations GPT d'OpenAI.
• faiss-cpu : une bibliothèque de Facebook AI pour une recherche de similarité efficace, utilisée pour stocker et rechercher des intégrations.
• numpy : pour les opérations numériques, y compris la gestion des plongements sous forme de vecteurs.
• python-dotenv : pour charger des variables d'environnement (par exemple, des clés API) à partir d'un fichier .env en toute sécurité.

2. Configurer les variables d'environnement

   • Accédez à https://platform.openai.com/settings/organization/api-keys
   • Cliquez sur « Créer une nouvelle clé secrète » comme indiqué dans l’image ci-dessous.
   • 
   • Fournissez des détails. Vous pouvez utiliser un compte de service. Donnez un nom à l'« ID de compte de service » et sélectionnez un projet.
   • Copier la clé secrète dans le presse-papiers
   • Créez un fichier .env dans le répertoire de votre projet. Ajoutez votre clé API OpenAI à ce fichier.

    OPENAI_API_KEY=your_openai_api_key_here

   • Ce fichier maintient votre clé API sécurisée et séparée du code.

     
     

3. Initialiser le client et charger les variables d’environnement

   • load_dotenv() charge le fichier .env et os.getenv("OPENAI_API_KEY") récupère la clé API. Cette configuration permet de sécuriser votre clé API.

 import os from openai import OpenAI from dotenv import load_dotenv import faiss import numpy as np # Load environment variables load_dotenv() client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

4. Définir la base de données/connaissances de base
   • Ce dictionnaire contient les informations de base sur les sujets. En réalité, il peut s'agir d'un ensemble de données plus vaste ou d'une base de données.

 # Grounding data grounding_data = { "Python": "Python is dynamically typed, which can be a double-edged sword. While it makes coding faster and more flexible, it can lead to runtime errors that might have been caught at compile-time in statically-typed languages.", "LLMs": "Large Language Models (LLMs) are neural networks trained on large text datasets.", "Data Science": "Data Science involves using algorithms, data analysis, and machine learning to understand and interpret data.", "Java": "Java is great, it powers most of the machine learning code, and has a rich set of libraries available." }

5. Générer des intégrations de texte

   • Une fonction permettant de générer des intégrations pour un texte donné à l'aide du modèle d'intégration d'OpenAI. Cette fonction appelle l'API OpenAI pour obtenir l'intégration d'une entrée de texte, qui est ensuite renvoyée sous forme de tableau NumPy

    # Function to generate embedding for a text def get_embedding(text): response = client.embeddings.create( model="text-embedding-ada-002", input=text ) return np.array(response.data[0].embedding)

   
   

6. Index FAISS et intégrations pour les données de mise à la terre

   • Créez un index FAISS, une structure optimisée pour des recherches de similarité rapides, et remplissez-le avec des incorporations des données de base.

    # Create FAISS index and populate it with grounding data embeddings dimension = len(get_embedding("test")) # Dimension of embeddings index = faiss.IndexFlatL2(dimension) # L2 distance index for similarity search grounding_embeddings = [] grounding_keys = list(grounding_data.keys()) for key, text in grounding_data.items(): embedding = get_embedding(text) grounding_embeddings.append(embedding) index.add(np.array([embedding]).astype("float32"))

7. 
   

   • dimension : La taille de chaque intégration, nécessaire pour initialiser l'index FAISS.
   • index = faiss.IndexFlatL2(dimension) : Crée un index FAISS qui utilise la distance euclidienne (L2) pour la similarité.
   • Pour chaque entrée dans grounding_data , ce code génère une incorporation et l'ajoute à l'index FAISS.

   
   

8. Fonction de recherche vectorielle

   • La fonction recherche dans l'index FAISS l'entrée de données de mise à la terre la plus similaire à une requête.

 # Function to perform vector search on FAISS def vector_search(query_text, threshold=0.8): query_embedding = get_embedding(query_text).astype("float32").reshape(1, -1) D, I = index.search(query_embedding, 1) # Search for the closest vector if I[0][0] != -1 and D[0][0] <= threshold: return grounding_data[grounding_keys[I[0][0]]] else: return None # No similar grounding information available

• Query Embedding : convertit le texte de la requête en un vecteur d’incorporation.
• FAISS Search : recherche dans l'index le vecteur le plus proche de la requête.
• Threshold Check : si la distance du vecteur le plus proche (D) est inférieure au seuil, les informations de mise à la terre sont renvoyées. Dans le cas contraire, aucune mise à la terre fiable n'a été trouvée.

8. Interroger le LLM

   Nous interrogeons le LLM en utilisant l'API chatgpt d'OpenAI et le modèle gpt-4.

    # Query the LLM def query_llm(prompt): response = client.chat.completions.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": prompt} ] ) return response.choices[0].message.content

9. Réponse améliorée

   • Ajoute des informations de mise à la terre si elles sont disponibles, ou
   • Ajoute une clause de non-responsabilité si aucune information de mise à la terre pertinente n'est trouvée.

    def enhance_response(topic, llm_response): grounding_info = vector_search(llm_response) if grounding_info: # Check if the LLM's response aligns well with grounding information return f"{llm_response}\n\n(Verified Information: {grounding_info})" else: # Add a disclaimer when no grounding data is available return f"{llm_response}\n\n(Disclaimer: This information could not be verified against known data and may contain inaccuracies.)"

10. Définir la fonction principale

    La fonction principale combine tout, vous permettant de saisir un sujet, d'interroger le LLM et de vérifier si la réponse correspond aux données de base.

     # Main function to execute the grounding check def main(): topic = input("Enter a topic: ") llm_response = query_llm(f"What can you tell me about {topic}?") grounding_info = vector_search(llm_response, threshold=0.8) print(f"LLM Response: {llm_response}") print(f"Grounding Information: {grounding_info}") if grounding_info != "No grounding information available": print("Response is grounded and reliable.") else: print("Potential hallucination detected. Using grounded information instead.") print(f"Grounded Answer: {grounding_info}") if __name__ == "__main__": main()

Résultat

Exécuter le script

Invoquer cet extrait en utilisant

 python groundin_llm.py

La réponse :

Explication

Si vous remarquez la réponse, bien que la réponse de LLM ait été « L’un des langages de programmation les plus recommandés pour l’apprentissage automatique… », la réponse fondée était « Java est génial, il alimente la plupart du code d’apprentissage automatique, il dispose d’un riche ensemble de bibliothèques disponibles ».

Ceci est possible en utilisant la bibliothèque FAISS de Meta pour la recherche vectorielle basée sur la similarité.

Processus :

1. Récupérez d’abord la réponse LLM.
2. Vérifiez si notre base de connaissances contient des informations pertinentes en utilisant la recherche vectorielle.
3. S'il existe, renvoie la réponse de « la base de connaissances »
4. Sinon, renvoyez la réponse LLM telle quelle.

Voici le code : https://github.com/sundeep110/groundingLLMs

Bon ancrage !!