Övervinna LLM-hallucinationer med hjälp av kunskapsbaser

Vad?

Om du frågar en LLM "föreslå ett bra programmeringsspråk för maskininlärning"

LLMs svar skulle vara: "Ett av de mest rekommenderade programmeringsspråken för maskininlärning är Python. Python är en hög nivå..."

Vad händer om du vill att din organisation ska tillhandahålla en verifierad organisationsspecifik information, dvs förbättra responsen med autentisk organisationsinformation?

Låt oss få det att hända när vi interagerar med LLM

Varför?

Populära LLMs som OpenAIs chatGPT, Googles Gemini utbildas på allmänt tillgänglig data. De saknar ofta organisationsspecifik information. Det finns vissa tillfällen då organisationer skulle vilja förlita sig på LLM:er. Vill dock förbättra responsen som är specifik för en viss organisation eller lägga till ansvarsfriskrivningar när ingen jordningsdata finns tillgänglig.

Processen att göra detta är känd som Grounding of LLM:s svar med hjälp av kunskapsbaser.

Hur?

Samtidigt kan jag bara prata om det.

Som ingenjör ger mig självförtroende att titta på några kodsnuttar.

Att utföra dem höjer mitt självförtroende och ger också lycka. Att dela ger mig tillfredsställelse 😄

Koda? Varför inte! → Python? Naturligtvis!!

1. Installera nödvändiga bibliotek

    pip install openai faiss-cpu numpy python-dotenv

• openai : För att interagera med OpenAI:s GPT-modeller och inbäddningar.
• faiss-cpu : Ett bibliotek av Facebook AI för effektiv likhetssökning, som används för att lagra och söka inbäddningar.
• numpy : För numeriska operationer, inklusive hantering av inbäddningar som vektorer.
• python-dotenv : För att ladda miljövariabler (t.ex. API-nycklar) från en .env fil på ett säkert sätt.

2. Ställ in miljövariabler

   • Navigera till https://platform.openai.com/settings/organization/api-keys
   • Klicka på "Skapa ny hemlig nyckel" som visas i bilden nedan.
   • 
   • Ange detaljer, Du kan använda ett tjänstekonto. Ange ett namn för "Tjänstkonto-ID" och välj ett projekt.
   • Kopiera den hemliga nyckeln till urklipp
   • Skapa en .env fil i din projektkatalog. Lägg till din OpenAI API-nyckel till den här filen.

    OPENAI_API_KEY=your_openai_api_key_here

   • Den här filen håller din API-nyckel säker och separerad från koden.

     
     

3. Initiera klient- och laddningsmiljövariabler

   • load_dotenv() laddar .env filen och os.getenv("OPENAI_API_KEY") hämtar API-nyckeln. Denna inställning håller din API-nyckel säker.

 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. Definiera jordningsdata/kunskapsbas
   • Denna ordbok innehåller grundinformation för ämnen. I verkligheten kan detta vara en större datamängd eller en databas.

 # 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. Generera textinbäddningar

   • En funktion för att generera inbäddningar för en given text med hjälp av OpenAI:s inbäddningsmodell. Denna funktion anropar OpenAI API för att få inbäddningen för en textinmatning, som sedan returneras som en NumPy-array

    # 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. FAISS Index och inbäddningar för jordningsdata

   • Skapa ett FAISS-index, en struktur optimerad för snabba likhetssökningar, och fyll den med inbäddningar av jordningsdata.

    # 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 : Storleken på varje inbäddning som behövs för att initiera FAISS-index.
   • index = faiss.IndexFlatL2(dimension) : Skapar ett FAISS-index som använder euklidiskt avstånd (L2) för likhet.
   • För varje post i grounding_data genererar denna kod en inbäddning och lägger till den i FAISS-index.

   
   

8. Vektor sökfunktion

   • Funktionen söker i FAISS-indexet efter den jordningsdatainmatning som mest liknar en fråga.

 # 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 : Konverterar frågetexten till en inbäddningsvektor.
• FAISS Search : Söker i indexet efter den vektor som ligger närmast frågan.
• Threshold Check : Om den närmaste vektorns avstånd (D) är under tröskeln, returnerar den jordningsinformationen. Annars indikerar det att ingen tillförlitlig jordning hittades.

8. Fråga LLM

   Vi frågar LLM med hjälp av OpenAI:s chatgpt api och gpt-4-modell.

    # 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. Förbättrad respons

   • Lägger till jordningsinformation om den är tillgänglig, eller
   • Lägger till en ansvarsfriskrivning om ingen relevant jordningsinformation hittas.

    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. Definiera huvudfunktionen

    Huvudfunktionen kombinerar allt, så att du kan mata in ett ämne, fråga i LLM och kontrollera om svaret överensstämmer med jordningsdata.

     # 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()

Resultat

Kör skriptet

Anropa detta utdrag med hjälp av

 python groundin_llm.py

Svaret:

Förklaring

Om du märker svaret, även om svaret från LLM var "Ett av de mest rekommenderade programmeringsspråken för maskininlärning ...", var det grundade svaret "Java är bra, det driver det mesta av maskininlärningskoden, den har en rik uppsättning av tillgängliga bibliotek”.

Detta är möjligt med hjälp av Metas FAISS-bibliotek för vektorsökning baserat på likhet.

Process :

1. Hämta först LLMs svar.
2. Kontrollera om vår kunskapsbas har någon relevant information med hjälp av vektorsökning.
3. Om det finns returnera svaret från "kunskapsbasen"
4. Om inte, returnera LLM-svaret som det är.

Här är koden: https://github.com/sundeep110/groundingLLMs

Happy Grounding!!