Grote taalmodellen verbeteren met kennisgrafen

Hoe kennisgrafen en LLM’s samenwerken

Laten we nu bekijken hoe kennisgrafen LLM’s kunnen versterken. 

Kennisgrafen voor contextueel begrip

LLM’s kunnen goedgeschreven tekst genereren, maar ze kunnen de feitelijke juistheid ervan niet beoordelen. In de meeste gevallen bevatte de oorspronkelijke trainingsdataset geen informatie (zoals een specifieke handleiding) die relevant is voor een praktische taak (zoals gebruikersvragen beantwoorden over het gebruik van een specifieke tool). 

Een LLM met toegang tot contextuele en domeinspecifieke informatie kan die kennis gebruiken om betekenisvolle en correcte antwoorden te formuleren. KG’s geven LLM’s programmatiche toegang tot relevante en feitelijke informatie, waardoor ze beter op gebruikersvragen kunnen reageren. 

LLM’s voor het bevragen en ontsluiten van kennisgrafen

Kennisgrafen zijn goed in het semantisch organiseren, opslaan en ophalen van informatie. Je kunt ze echter alleen benaderen via gespecialiseerde querytalen zoals SPARQL (een databasequerytaal voor het bewerken en ophalen van data in RDF-formaat). 

De output van KG’s is ook in codevorm en gebruikers hebben specifieke training nodig om die te interpreteren. LLM’s overbruggen deze kloof door platte taal van gebruikers om te zetten naar een querytaal en door mensleesbare tekst te genereren uit de output van de KG. Zo kunnen niet-technische gebruikers met KG’s werken. 

Dynamische kennisintegratie

De tekst die LLM’s genereren is afhankelijk van de trainingsdataset, die vaak verouderd is tegen de tijd dat het LLM in productie gaat. LLM’s continu hertrainen op actuele informatie kost veel middelen en is dus onpraktisch. 

KG’s kunnen daarentegen, net als andere databases, eenvoudig realtime worden bijgewerkt. Er is slechts een kleine rekenkundige overhead om de verbindingen tussen knopen op basis van nieuwe informatie bij te werken. Door te integreren met KG’s kunnen LLM’s dus informatie in realtime benaderen en actuele antwoorden geven. 

Voorbeeldworkflow

De onderstaande stappen schetsen een voorbeeldworkflow die KG’s en LLM’s samen gebruikt om actuele antwoorden op gebruikersvragen te geven. 

1. De gebruiker voert zijn vraag in natuurlijke taal in.
2. Het LLM genereert op basis van de gebruikersvraag een query in een programmeertaal.
3. De KG ontvangt de query van het LLM en retourneert de relevante informatie als ruwe data (bijv. JSON). 
4. Het LLM genereert een antwoord in natuurlijke taal op basis van de output van de KG.
5. De gebruiker ontvangt het antwoord in natuurlijke taal. 

De onderstaande figuur toont een schematische weergave van deze stappen: 

Figuur 1: LLM + KG-workflow (afbeelding door auteur)

Use-cases van kennisgrafen in generatieve AI

Er zijn veel use-cases mogelijk dankzij de integratie van KG’s en GenAI. Laten we de interessantste bekijken. 

Verbeterde conversational AI

KG’s bieden een gestructureerde en actuele kennisbron die een chatbot programmatisch kan benaderen om actuele informatie op te halen en relevantere antwoorden te geven op gebruikersvragen. 

De KG vult de standaardkennis van de chatbot aan, die gebaseerd is op de trainingsdataset. De chatbot leert zinnen bouwen op basis van de trainingsdata en krijgt toepassingsspecifieke informatie uit de KG. Daardoor kun je met KG’s dezelfde chatbotarchitectuur voor verschillende toepassingen gebruiken zonder te hertrainen.

Persoonlijke aanbevelingen

LLM’s zijn gebruikt als aanbevelingssystemen. 

Zo kan een LLM de inhoud van een artikel analyseren en relevante artikelen aanbevelen. LLM’s worden ook gebruikt om interactieve systemen te maken, waarbij de gebruiker “kan praten” met de aanbevelingsmachine.

KG’s kunnen informatie over gebruikersgedrag, interesses, interacties enzovoort organiseren en opslaan. LLM’s kunnen deze informatie analyseren en gebruiken om op maat gemaakte reacties te genereren. Zo profiteren gebruikers van persoonlijke aanbevelingen op basis van hun individuele voorkeuren. 

Wetenschappelijk onderzoek en domeinspecifieke toepassingen

In kennisintensieve domeinen zoals geneeskunde, financiën en recht verbeteren LLM’s in combinatie met KG’s de toegankelijkheid van informatie. 

In de geneeskunde suggereren ze mogelijke diagnoses op basis van symptomen en voorgeschiedenis. In de financiële sector ondersteunen ze analisten door relevante informatie uit financiële rapporten makkelijker toegankelijk te maken. In het recht helpen ze juristen bij het terugvinden van relevante jurisprudentie en het samenvatten van omvangrijke juridische documenten. 

Realtime kennisopvraging

Het combineren van grote taalmodellen met kennisgrafen is cruciaal in realtime toepassingen zoals nieuwsaggregatie en aandelenmarktanalyse. 

Traditionele LLM’s weten niets van gebeurtenissen die niet in hun training voorkwamen. Daardoor kunnen ze geen zinvolle antwoorden geven op vragen over actualiteiten. 

KG’s zijn efficiënt in het verwerken en ordenen van nieuwe informatie in realtime. Zo vormen ze de informatica-backend voor LLM’s om toepassingen met actualiteiten (nieuwsaggregatie) en snel veranderende omgevingen (bijv. de aandelenmarkt) aan te kunnen. 

Tools en frameworks voor kennisgrafen in generatieve AI

De vorige secties bespraken de basisprincipes van LLM’s en KG’s. In deze sectie introduceren we de tools en libraries voor de integratie van KG’s en LLM’s. 

Grafdatabasetools

KG’s worden meestal geïmplementeerd met grafdatabases zoals:

Neo4j

Een gespecialiseerde grafdatabase (werkt uitsluitend met grafen). Neo4j gebruikt Cypher, een declaratieve grafquerytaal, om informatie in te voegen en op te halen. Cypher lijkt qua stijl op SQL, wat het voor ontwikkelaars makkelijker maakt om te leren. 

Neo4j beheert complex onderling verbonden data efficiënt omdat de onderliggende opslagengine vanaf de grond is opgebouwd voor grafdatabase-use-cases. Het is een populaire keuze omdat het verbinding maakt met externe databronnen zoals Apache Kafka en eenvoudig horizontaal schaalt.

ArangoDB

ArangoDB is een multimodel-grafdatabase. Naast grafen ondersteunt het ook JSON-documenten en key-value stores. Hierdoor kun je grafen verrijken met andere informatie die zich niet eenvoudig laat omzetten naar grafformaat. 

Dankzij deze flexibiliteit heeft het vaak de voorkeur in enterprise-toepassingen die met verschillende datatypes werken. Het gebruikt de Arango Query Language (AQL) om over alle datatypes heen te werken. Onder de motorkap gebruikt ArangoDB RocksDB als opslagengine. 

Amazon Neptune

Amazon Neptune ondersteunt property graphs en RDF (Resource Description Framework)-modellen. Het gebruikt de querytalen SPARQL en Gremlin. Het integreert naadloos in de AWS-infrastructuur om als volledig beheerde grafdatabase te draaien, waardoor het vaak wordt gekozen voor integratie met bestaande enterprise-infrastructuur. 

Libraries voor integratie

LLM’s en grafdatabases vullen elkaar aan maar kunnen doorgaans niet direct met elkaar communiceren. In de volgende alinea’s bespreken we integratielibraries en frameworks die data van KG’s naar LLM’s en omgekeerd doorgeven. 

RDFlib

RDFlib is een open-source Python-package voor werken met RDF-data. Het heeft functies om RDF-grafen te manipuleren en te bevragen. Dit vergemakkelijkt de integratie met kennisgrafen. Je kunt RDF-data in het geheugen, op schijf of op afstand via SPARQL-endpoints opslaan. Een SPARQL-endpoint, analoog aan een API-endpoint, kan externe SPARQL-queries ontvangen en verwerken. 

RDFlib werkt met grafgebaseerde datastructuren die uit subject-predicaat-objecttriples bestaan. Elk onderdeel van de triple is een URI of een letterlijke waarde. Het heeft functies om triples, XML en andere datatypes zoals JSON-LD te parsen en te serialiseren.

PyTorch Geometric 

PyTorch Geometric (PyG) is een op PyTorch gebaseerde library die is ontworpen om te trainen met Graph Neural Networks (GNN’s) te maken. Een GNN is een neurale netwerkarchitectuur die op grafen werkt en graafdatastructuren als input kan accepteren. PyG heeft functies om deep learning-technieken op grafen toe te passen. 

PyG wordt geleverd met veel voorgebouwde GNN-architecturen die je direct kunt implementeren of verder kunt uitbreiden via de message-passing-API. 

PyG zou geschikt zijn voor grootschalige toepassingen met miljoenen knopen over verschillende typen knopen en randen. Dit subveld staat ook bekend als geometrisch deep learning. 

Traditionele neurale netwerken zijn goed in het encoderen van lineaire relaties, maar data uit de echte wereld is vaak complex en multidimensionaal. Grafen representeren beter hogere-dimensionale verbanden waarin elke knoop in een graaf met elke andere knoop kan samenhangen. Daardoor zijn grafen beter geschikt om complexe relaties uit de echte wereld op te slaan. 

LangChain

LangChain werd in 2022 gelanceerd als integratiekader voor taalmodellen. Het faciliteert het bouwen van gebruikersapplicaties door LLM’s te koppelen aan andere relevante tools, zoals API-wrappers, shellscripts, webscrapers, PDF-lezers, Google Docs, relationele databases, vectordatabases en grafdatabases (inclusief KG’s). Het wordt daarom veel gebruikt om toepassingen met LLM’s te bouwen. 

OpenAI API

OpenAI-API’s nemen de moeite weg om een pijplijn te bouwen met tools zoals PyG. De OpenAI API kan een natuurlijke-taalvraag van een gebruiker ontvangen, die begrijpen en een gestructureerde query in een programmeertaal (bijv. SPARQL) teruggeven. Deze query gaat naar de KG, die de relevante data retourneert. Die data gaat terug naar de OpenAI API, samen met de context van de oorspronkelijke vraag. Het OpenAI-LLM genereert vervolgens een antwoord in natuurlijke taal op basis van de data uit de KG. 

Met OpenAI-API’s kun je kiezen uit verschillende LLM’s, afhankelijk van taak en budget. Je hoeft dus geen LLM’s te deployen of de datapijplijnen te bouwen om met de KG te koppelen. 

Voorbeeld van een integratieworkflow

In deze sectie geven we een illustratie op hoog niveau van een integratiepijplijn met pseudocode. 

We gebruiken Neo4j, LangChain en de OpenAI API om de stappen te tonen voor het bouwen van een chatbot op basis van RAG. Het LLM genereert zijn antwoord op basis van informatie die in de KG is opgeslagen. 

## Import relevant packages 

# Handling chat prompts
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.prompts.prompt import PromptTemplate
from langchain_openai import ChatOpenAI

# Implementing the Runnable protocol for chaining components
from langchain_core.runnables import (
    RunnableBranch,
    RunnableLambda,
    RunnableParallel,
    RunnablePassthrough,

# Processing text inputs in the chat
from langchain_core.messages import AIMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser

# Working with Neo4j graphs
from neo4j import GraphDatabase
from langchain_community.graphs import Neo4jGraph
from langchain_experimental.graph_transformers import LLMGraphTransformer

# Vector embeddings for the LLM
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Neo4jVector

# Load data from a source like Wiki, PDF documents, etc. 
from langchain.document_loaders import WikipediaLoader

# Create a Neo4jGraph to store the KG
graph = Neo4jGraph()

# Load the document(s) based on which to build the KG. In this snippet, we use Wiki. In practice, this is a business-specific document
raw_documents = WikipediaLoader(...).load() 

# Split the document into tokens
documents = create_tokens(raw_documents)

# Instantiate the LLM
llm = ChatOpenAI(model_name="...", …) 
llm_transformer = LLMGraphTransformer(llm=llm)

# Use the LLM to convert the tokenized documents into graph entities
graph_docs = llm_transformer.convert_to_graph_documents(documents)

# Add the graph entities to the Neo4j graph
graph.add_graph_documents(graph_docs, …) 

# Create a retriever to run on the graph
graph.query(
    "CREATE FULLTEXT INDEX entity IF NOT EXISTS FOR (e:__Entity__) ON EACH [e.id]")

# Create a class to extract entities from the text corresponding to nodes from the graph 
class Entities(BaseModel):
    names: List[str] = Field(
        ...,
        description="All the person, organization, or business entities that appear in the text",
    )

# Create a prompt template 
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are extracting organization and person entities from the text.",
        ),
        (
            "human",
            "Use the given format to extract information from the following "
            "input: {question}",
        ),
    ]
)

# Create a chain by piping the prompt to the LLM with the Entities class. 
# This chain identifies entities in a given prompt string
entity_chain = prompt | llm.with_structured_output(Entities)


# Create a structured retriever to extract the entities in the query. Given a text query, it retrieves all the relevant nodes in the neighborhood of the entities in that query. 

def structured_retriever(question: str) -> str:
    result = ""
    entities = entity_chain.invoke({"question": question})
    for entity in entities.names:
        response = graph.query(
        # CYPHER QUERY TEMPLATE, 
        {"query": generate_full_text_query(entity)})
        result += el['output'] for el in response
    return result

# Chain together the different components 
chain = (
    RunnableParallel(
        {
            "context": _search_query | retriever,
            "question": RunnablePassthrough(),
        }
    )
    | prompt
    | llm
    | StrOutputParser()
)

# Invoke the chain
chain.invoke({"question": "The user’s question goes here"})

Best practices voor het combineren van kennisgrafen en LLM’s

KG’s vergroten de mogelijkheden van LLM’s en maken ze relevanter voor praktische use-cases. Voor de beste prestaties raad ik de volgende best practices aan.

Houd grafen up-to-date

De KG bevat de kennisbron waarop het LLM zijn antwoorden baseert. Daarom is het noodzakelijk de grafdatabase continu met de nieuwste informatie bij te werken. Een verouderde KG leidt ertoe dat het LLM verouderde antwoorden geeft. 

Optimaliseer query-efficiëntie

LLM’s en KG’s zijn complexe software met hoge rekenvereisten. Zoals in de vorige sectie te zien is, omvat het koppelen van LLM’s en KG’s veel stappen, van het tokenizen van de gebruikersvraag en het genereren van de relevante grafquery tot het ophalen van de informatie uit de KG en het genereren van tekst daaruit. 

Dit kan leiden tot inefficiënties en vertraging tussen vraag en antwoord. Optimalisatie-methoden, zoals hieronder uitgelegd, helpen de latency te minimaliseren. 

• Caches slaan vaak geraadpleegde data op in snel geheugen. Zo hoef je veelgebruikte resultaten niet telkens opnieuw te berekenen.
• Queryresultaten: Key-valuestores kunnen worden gebruikt om de resultaten van veelvoorkomende queries naar de KG op te slaan
• LLM-embeddings: De embeddingvectoren voor veelgebruikte inputvragen kunnen worden gecachet om herhaaldelijke toegang tot de LLM-API te vermijden. Dit bespaart zowel tijd als kosten. 
• Queryoptimalisatie omvat het herschrijven van databasequeries en het gebruiken van de juiste indexen om database-toegang efficiënter te maken. 
• Indexen helpen snel toegang te krijgen tot graafelementen zoals knopen, relaties en hun eigenschappen. De juiste soorten indexen (op vaak gebruikte data) versnellen queries en relatie-lookups. 
• Queryparametrisering creëert en cachet geoptimaliseerde en geparametriseerde versies van veelvoorkomende querystructuren met placeholders voor de termen uit de gebruikersvraag. Dit maakt het uitvoeren en retourneren van gebruikersvragen sneller. 
• Asynchroon bevragen zorgt ervoor dat het LLM niet hoeft te wachten tot de KG een antwoord terugstuurt. Het LLM kan meerdere databasequeries uitsturen en met de reacties werken zodra die binnenkomen. 
• Loadbalancing helpt gebruikersvragen te verdelen over replica-databases en taalmodellen. Bepaal of het LLM of de KG de bottleneck is en schaal die horizontaal uit zodat andere ketenonderdelen kunnen blijven verwerken. 

Verklein de grootte van taalmodellen

LLM’s zijn geheugenintensief en hebben vaak dure hardware nodig. Het helpt om AI-modellen te verkleinen met technieken zoals LLM-distillatie en kwantisatie:

• LLM-distillatie is een techniek waarbij een kleiner model, het studentmodel, de antwoorden van een groter (docent)model nabootst. Alleen het docentmodel wordt op de oorspronkelijke dataset getraind; het studentmodel wordt uitsluitend getraind om de antwoorden van de docent op een groot aantal inputs te evenaren. Dit heet kennisdistillatie en is veel goedkoper dan een model vanaf nul trainen. De prestaties van de student zijn echter mogelijk minder betrouwbaar voor nieuwe vragen waarop niet is getraind. 
• LLM’s kwantiseren houdt in dat je de precisie van de modelgewichten verlaagt. Het grootste deel van het geheugen- en rekenwerk van een AI-model komt door grootschalige matrixvermenigvuldigingen op de modelgewichten. De gewichten van basismodellen worden doorgaans voorgesteld als 32-bit- of 16-bit-floatingpointgetallen. Er is geobserveerd dat het verlagen van de precisie van modelgewichten naar 8-bit-integers (en in sommige gevallen zelfs lager, tot 1-bit) vergelijkbare prestaties oplevert tegen een fractie van de grootte en kosten. 

Evalueer LLM-prestaties

Je moet ervoor zorgen dat het gekozen taalmodel goed presteert bij het soort vragen dat het moet afhandelen. 

Tools zoals MLFlow helpen LLM-prestaties te evalueren bij verschillende taken. Net zoals de behoeften van gebruikers veranderen en evolueren, verandert ook de informatie in de kennisgraaf in de tijd. Daarom is het essentieel om de prestaties van het LLM periodiek na deployment opnieuw te evalueren. Mogelijk is het nodig het model te finetunen op een bijgewerkte dataset, een bijgewerkte modelversie te gebruiken of zelfs een nieuw model te deployen. 

Finetunen met domeinspecifieke data

Het LLM haalt informatie uit de KG en zijn taal- en redeneervermogen uit de trainingsdataset. 

Basismodellen zijn getraind op grote generieke datasets, meestal met tekst van het hele internet. Finetunen van het LLM op een domeinspecifieke dataset verbetert zijn redeneervermogen in dat domein en zorgt dat het zinnen met de juiste structuur en jargon kan bouwen. Wil je bijvoorbeeld een LLM gebruiken om medische vragen te beantwoorden met een medische KG, dan raad ik sterk aan het basis-LLM te finetunen op een dataset met medische teksten. 

Conclusie

In dit artikel bespraken we de fundamentele principes van grote taalmodellen (LLM’s) en kennisgrafen (KG’s) en hoe ze elkaar aanvullen. We hebben ook enkele veelgebruikte tools geïntroduceerd om LLM’s en KG’s samen te gebruiken voor gebruikersgerichte toepassingen. Tot slot gaven we een illustratie op hoofdlijnen van hoe Neo4j en OpenAI samen met LangChain kunnen worden ingezet.

Na het begrijpen van deze basisconcepten kun je deze tools in de praktijk toepassen:

• Bekijk als eerste stap de introductiecursus LLM’s met Python.
• Ben je al bekend met de basis van LLM’s, bekijk dan LangChain om een Retrieval Augmented Generation (RAG)-systeem te bouwen.
• Als je productiesystemen uitrolt, overweeg dan de cursus Concepten van LLMOps.