नॉलेज ग्राफ़्स के साथ बड़े भाषा मॉडलों को बेहतर बनाना

नॉलेज ग्राफ़्स और LLMs साथ मिलकर कैसे काम करते हैं

अब देखते हैं कि नॉलेज ग्राफ़्स का उपयोग LLMs को बेहतर बनाने के लिए कैसे किया जा सकता है। 

प्रसंगात्मक समझ के लिए नॉलेज ग्राफ़्स

LLMs सुव्यवस्थित पाठ जनरेट करने में सक्षम हैं, लेकिन वे उसकी तथ्यात्मक सटीकता का आकलन नहीं कर सकते। अधिकांश मामलों में, मूल प्रशिक्षण डेटासेट में व्यावहारिक कार्य के लिए प्रासंगिक जानकारी (जैसे किसी विशिष्ट यूज़र मैनुअल) नहीं होती (जैसे किसी विशेष टूल का उपयोग कैसे करें इस पर उपयोगकर्ता प्रश्नों का उत्तर देना)। 

संदर्भात्मक और डोमेन-विशिष्ट जानकारी तक पहुँच वाले LLM उस ज्ञान का उपयोग करके सार्थक और सही उत्तर तैयार कर सकते हैं। KGs LLMs को प्रोग्रामेटिक रूप से प्रासंगिक और तथ्यात्मक जानकारी एक्सेस करने देते हैं, जिससे वे उपयोगकर्ता प्रश्नों का बेहतर उत्तर दे पाते हैं। 

नॉलेज ग्राफ़्स को क्वेरी और इंटरफ़ेस करने के लिए LLMs

नॉलेज ग्राफ़्स अर्थपूर्ण ढंग से जानकारी को संगठित करने, संग्रहीत करने और पुनर्प्राप्त करने में अच्छे हैं। हालाँकि, उन्हें केवल SPARQL (RDF फ़ॉर्मेट में संग्रहीत डेटा को संसाधित और पुनर्प्राप्त करने के लिए एक डाटाबेस क्वेरी भाषा) जैसी विशिष्ट क्वेरी भाषाओं के माध्यम से ही एक्सेस किया जा सकता है। 

KGs का आउटपुट भी कोड-आकार में होता है और उपयोगकर्ताओं को इसे समझने के लिए विशेष प्रशिक्षण चाहिए होता है। LLMs, सादे भाषा के उपयोगकर्ता अनुरोधों को क्वेरी भाषा में बदलकर और KG के आउटपुट से मानव-पठनीय पाठ जनरेट करके यह अंतर पाटते हैं। इस तरह, वे गैर-तकनीकी उपयोगकर्ताओं को KGs के साथ इंटरफ़ेस करने देते हैं। 

डायनामिक नॉलेज इंटीग्रेशन

LLMs द्वारा जनरेट किया गया पाठ प्रशिक्षण डेटासेट पर निर्भर करता है, जो अक्सर मॉडल के प्रोडक्शन में आने तक पुराना हो चुका होता है। LLMs को लगातार नवीनतम जानकारी पर फिर से प्रशिक्षित करना संसाधन-गहन और व्यावहारिक रूप से कठिन है। 

लेकिन KGs, अन्य डाटाबेस की तरह, रियल-टाइम में आसानी से अपडेट किए जा सकते हैं। नई जानकारी के आधार पर नोड्स के बीच कनेक्शनों को अपडेट करने में केवल थोड़ा कम्प्यूटेशनल ओवरहेड लगता है। इसलिए, KGs के साथ एकीकरण करके, LLMs रियल-टाइम में अपडेट हुई जानकारी तक पहुँच सकते हैं और अद्यतन प्रतिक्रियाएँ दे सकते हैं। 

उदाहरण वर्कफ़्लो

नीचे दिए गए चरण KGs और LLMs को साथ मिलाकर उपयोगकर्ता प्रश्नों के अद्यतन उत्तर देने वाले एक उदाहरण वर्कफ़्लो के मुख्य चरणों की रूपरेखा प्रस्तुत करते हैं। 

1. उपयोगकर्ता अपना प्रश्न प्राकृतिक भाषा में दर्ज करता/करती है।
2. LLM उपयोगकर्ता के अनुरोध के आधार पर एक प्रोग्रामिंग भाषा क्वेरी जनरेट करता है।
3. KG LLM से क्वेरी प्राप्त करता है और संबंधित जानकारी को रॉ डेटा (उदा., JSON) के रूप में लौटाता है। 
4. LLM KG के आउटपुट के आधार पर प्राकृतिक भाषा में प्रतिक्रिया जनरेट करता है।
5. उपयोगकर्ता को उसकी प्रतिक्रिया प्राकृतिक भाषा में प्राप्त होती है। 

नीचे का चित्र इन चरणों का एक योजनाबद्ध स्केच दिखाता है: 

चित्र 1: LLM + KG वर्कफ़्लो (छवि: लेखक)

जनरेटिव एआई में नॉलेज ग्राफ़्स के उपयोग के मामले

KGs और GenAI के एकीकरण से कई उपयोग के मामले सक्षम होते हैं। आइए सबसे दिलचस्प उदाहरणों की समीक्षा करें। 

उन्नत संवादात्मक एआई

KGs एक संरचित और अद्यतन नॉलेज रिपॉज़िटरी प्रदान करते हैं जिसे चैटबॉट प्रोग्रामेटिक रूप से एक्सेस करके वर्तमान जानकारी ले सकता है और उपयोगकर्ता प्रश्नों के लिए अधिक प्रासंगिक उत्तर दे सकता है। 

KG चैटबॉट के डिफ़ॉल्ट ज्ञान का पूरक होता है, जो प्रशिक्षण डेटासेट पर आधारित होता है। चैटबॉट प्रशिक्षण डेटासेट के आधार पर वाक्य बनाना सीखता है और एप्लिकेशन-विशिष्ट जानकारी KG से प्राप्त करता है। इस प्रकार, KGs का उपयोग करने से बिना पुन:प्रशिक्षण के एक ही चैटबॉट आर्किटेक्चर को विभिन्न अनुप्रयोगों के लिए उपयोग करना भी संभव होता है।

व्यक्तिगत अनुशंसाएँ

LLMs का उपयोग रिकमेंडेशन इंजन के रूप में किया गया है। 

उदाहरण के लिए, कोई LLM किसी लेख की सामग्री का विश्लेषण करके संबंधित लेखों की अनुशंसा कर सकता है। LLMs का उपयोग इंटरैक्टिव प्रणालियाँ बनाने में भी होता है, जहाँ उपयोगकर्ता रिकमेंडेशन इंजन से “बात” कर सकता/सकती है।

KGs उपयोगकर्ता के व्यवहार, रुचियों, इंटरैक्शनों आदि पर जानकारी को व्यवस्थित और संग्रहीत कर सकते हैं। LLMs इस जानकारी का विश्लेषण करके इसके आधार पर अनुकूलित प्रतिक्रियाएँ जनरेट कर सकते हैं। इस प्रकार, उपयोगकर्ताओं को उनकी व्यक्तिगत प्राथमिकताओं के आधार पर वैयक्तिकृत अनुशंसाओं का लाभ मिलता है। 

वैज्ञानिक शोध और डोमेन-विशिष्ट अनुप्रयोग

चिकित्सा, वित्त और क़ानून जैसे ज्ञान-आधारित डोमेनों में, KGs के साथ LLMs जानकारी तक पहुँचने की सुविधा को बेहतर बनाते हैं। 

चिकित्सा में, वे रोगी के लक्षणों और इतिहास के आधार पर संभावित निदान सुझाते हैं। वित्त में, वे विश्लेषकों के प्रयासों को पूरक बनाते हैं, वित्तीय रिपोर्टों से प्रासंगिक जानकारी तक पहुँच आसान बनाकर। क़ानून में, वे वकीलों की मदद करते हैं—प्रासंगिक पूर्व मामलों और निर्णयों को ढूँढने तथा बड़े कानूनी दस्तावेजों के सार प्रदान करने में। 

रियल-टाइम नॉलेज रिट्रीवल

Large Language Models को नॉलेज ग्राफ़्स के साथ जोड़ना समाचार समेकन और स्टॉक मार्केट विश्लेषण जैसी रियल-टाइम अनुप्रयोगों में महत्वपूर्ण है। 

पारंपरिक LLMs उन घटनाओं के बारे में नहीं जानते जो प्रशिक्षण के समय तक नहीं हुई थीं। इसलिए, वे वर्तमान घटनाओं पर आधारित प्रश्नों के सार्थक उत्तर नहीं दे पाते। 

KGs रियल-टाइम में नई जानकारी को प्रोसेस और व्यवस्थित करने में कुशल हैं। इसलिए, वे LLMs के लिए सूचना संबंधी बैकएंड प्रदान करते हैं ताकि वे चालू घटनाओं (समाचार समेकन) और तीव्र गति से बदलते परिवेश (उदा., स्टॉक मार्केट) पर आधारित अनुप्रयोगों को संभाल सकें। 

जनरेटिव एआई में नॉलेज ग्राफ़्स को लागू करने के टूल्स और फ़्रेमवर्क

पिछले अनुभागों में LLMs और KGs के मूल सिद्धांतों पर चर्चा की गई। इस अनुभाग में, हम KGs और LLMs के एकीकरण के लिए उपयोग किए जाने वाले टूल्स और लाइब्रेरी प्रस्तुत करते हैं। 

ग्राफ़ डाटाबेस टूल्स

KGs को आमतौर पर इन ग्राफ़ डाटाबेस का उपयोग करके इम्प्लीमेंट किया जाता है:

Neo4j

एक विशिष्ट ग्राफ़ डाटाबेस (यह केवल ग्राफ़्स के साथ काम करता है)। Neo4j Cypher का उपयोग करता है, जो एक डिक्लेरेटिव ग्राफ़ क्वेरी भाषा है, सूचना डालने और पुनर्प्राप्त करने के लिए। Cypher शैलीगत रूप से SQL के समान है, जिससे डेवलपर्स के लिए इसे सीखना आसान होता है। 

Neo4j जटिल परस्पर जुड़े डेटा को कुशलतापूर्वक प्रबंधित करता है क्योंकि इसका आधारभूत डेटा स्टोरेज इंजन ग्राफ़ डाटाबेस उपयोग मामलों के अनुरूप शून्य से बनाया गया है। यह एक लोकप्रिय विकल्प है क्योंकि यह Apache Kafka जैसे बाहरी डेटा स्रोतों से जुड़ता है और क्षैतिज रूप से स्केल करना आसान है।

ArangoDB

ArangoDB एक मल्टी-मॉडल ग्राफ़ डाटाबेस है। ग्राफ़्स के अलावा, यह JSON डॉक्युमेंट्स और की-वैल्यू स्टोर्स का भी समर्थन करता है। इससे उपयोगकर्ता उन जानकारियों से ग्राफ़्स को समृद्ध कर सकते हैं जिन्हें आसानी से ग्राफ़ फ़ॉर्मेट में बदला नहीं जा सकता। 

इस लचीलापन के कारण, यह अक्सर ऐसे एंटरप्राइज़ अनुप्रयोगों के लिए पसंद किया जाता है जो विभिन्न प्रकार के डेटा से निपटते हैं। यह Arango Query Language (AQL) का उपयोग सभी डेटा प्रकारों पर काम करने के लिए करता है। अंदरूनी तौर पर, ArangoDB डेटा स्टोरेज इंजन के रूप में RocksDB का उपयोग करता है। 

Amazon Neptune

Amazon का Neptune प्रॉपर्टी ग्राफ़्स और RDF (Resource Description Framework) मॉडल्स का समर्थन करता है। यह SPARQL और Gremlin क्वेरी भाषाओं का उपयोग करता है। यह AWS इन्फ्रास्ट्रक्चर में सहजता से एकीकृत होकर पूरी तरह मैनेज्ड ग्राफ़ डाटाबेस के रूप में चलता है, जिससे मौजूदा इन्फ्रास्ट्रक्चर में एंटरप्राइज़ अनुप्रयोगों के लिए एकीकरण का सामान्य विकल्प बनता है। 

इंटीग्रेशन के लिए लाइब्रेरी

LLMs और ग्राफ़ डाटाबेस एक-दूसरे के पूरक हैं, लेकिन सामान्यतः सीधे इंटरफ़ेस नहीं कर सकते। निम्नलिखित अनुच्छेदों में, हम ऐसी इंटीग्रेशन लाइब्रेरी और फ़्रेमवर्क पर चर्चा करते हैं जो KGs से LLMs और LLMs से KGs तक डेटा पहुँचाने के लिए उपयोग होते हैं। 

RDFlib

RDFlib RDF डेटा के साथ काम करने के लिए एक ओपन-सोर्स Python पैकेज है। इसमें RDF ग्राफ़्स को संसाधित और क्वेरी करने के फ़ंक्शन होते हैं। यह नॉलेज ग्राफ़्स के साथ इंटीग्रेशन को सुगम बनाता है। यह RDF डेटा को मेमोरी में, डिस्क पर, या SPARQL एंडपॉइंट्स का उपयोग करके रिमोटली स्टोर करने की अनुमति देता है। SPARQL एंडपॉइंट, API एंडपॉइंट के समान, रिमोट SPARQL क्वेरियाँ प्राप्त और प्रोसेस कर सकता है। 

RDFlib सब्जेक्ट-प्रेडिकेट-ऑब्जेक्ट ट्रिपल्स से बने ग्राफ़-आधारित डेटा स्ट्रक्चर के साथ काम करता है। ट्रिपल के प्रत्येक घटक एक URI या लिटरल वैल्यू होते हैं। इसमें ट्रिपल्स, XML और JSON-LD जैसे अन्य डेटा प्रकारों को पार्स और सीरियलाइज़ करने के फ़ंक्शन हैं।

PyTorch Geometric 

PyTorch Geometric (PyG) एक PyTorch-आधारित लाइब्रेरी है, जिसे ग्राफ़ न्यूरल नेटवर्क (GNNs) बनाने और प्रशिक्षित करने के लिए डिज़ाइन किया गया है। GNN एक न्यूरल नेटवर्क आर्किटेक्चर है जो ग्राफ़्स पर काम करता है और इनपुट के रूप में ग्राफ़ डेटा स्ट्रक्चर स्वीकार कर सकता है। PyG में ग्राफ़्स पर डीप लर्निंग तकनीकें लागू करने के फ़ंक्शन हैं। 

PyG कई प्री-बिल्ट GNN आर्किटेक्चर के साथ आता है जिन्हें सीधे लागू किया जा सकता है या मैसेज-पासिंग API के माध्यम से आगे बढ़ाया जा सकता है। 

दावा किया जाता है कि PyG विभिन्न प्रकार के नोड्स और एजेज़ में फैले लाखों नोड्स वाले बड़े पैमाने के अनुप्रयोगों के लिए उपयुक्त है। इस उपक्षेत्र को ज्योमेट्रिक डीप लर्निंग भी कहा जाता है। 

पारंपरिक न्यूरल नेटवर्क रैखिक संबंधों को एन्कोड करने में अच्छे हैं, लेकिन वास्तविक दुनिया का डेटा जटिल और बहु-आयामी होता है। ग्राफ़ उच्च-आयामी इंटरकनेक्शनों का प्रतिनिधित्व करने में बेहतर हैं, जहाँ किसी भी ग्राफ़ में कोई भी नोड किसी अन्य नोड से संबंधित हो सकता है। इससे ग्राफ़ वास्तविक दुनिया के जटिल संबंधों को संग्रहीत करने के लिए अधिक उपयुक्त बनते हैं। 

LangChain

LangChain को 2022 में एक भाषा मॉडल इंटीग्रेशन फ़्रेमवर्क के रूप में लॉन्च किया गया था। यह LLMs को अन्य संबंधित टूल्स, जैसे API रैपर्स, शेल स्क्रिप्ट्स, वेब स्क्रेपर्स, PDF रीडर्स, Google Docs, रिलेशनल डाटाबेस, वेक्टर डाटाबेस और ग्राफ़ डाटाबेस (KGs सहित) के साथ चेन करके यूज़र एप्लिकेशन बनाने में सुविधा देता है। इसलिए, इसे LLMs से संबंधित एप्लिकेशन बनाने में आमतौर पर उपयोग किया जाता है। 

OpenAI API

OpenAI APIs, PyG जैसे टूल्स का उपयोग करके पाइपलाइन बनाने की झंझट को दूर करते हैं। OpenAI API उपयोगकर्ता की प्राकृतिक भाषा क्वेरी प्राप्त कर सकता है, उसे समझ सकता है, और प्रोग्रामिंग भाषा (उदा., SPARQL) में एक संरचित क्वेरी लौटा सकता है। यह क्वेरी KG में दी जाती है, जो संबंधित डेटा लौटाता है। यह डेटा, मूल क्वेरी के संदर्भ के साथ, OpenAI API को वापस भेजा जाता है। OpenAI LLM, KG से पुनर्प्राप्त डेटा के आधार पर प्राकृतिक भाषा में प्रतिक्रिया जनरेट करता है। 

OpenAI APIs आपको कार्य और बजट के अनुसार विभिन्न LLMs में से चुनने देते हैं। इस प्रकार, आपको LLMs या KG के साथ इंटरफ़ेस करने के लिए डेटा पाइपलाइनों को डिप्लॉय करने की आवश्यकता नहीं है। 

उदाहरण इंटीग्रेशन वर्कफ़्लो

इस अनुभाग में, हम स्यूडो-कोड का उपयोग करके एक इंटीग्रेशन पाइपलाइन का उच्च-स्तरीय चित्रण प्रदान करते हैं। 

हम Neo4j, LangChain और OpenAI API का उपयोग करके RAG आधारित चैटबॉट बनाने के चरण दिखाते हैं। LLM अपनी प्रतिक्रिया KG में संग्रहीत जानकारी के आधार पर जनरेट करता है। 

## 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"})संचालित द्वारा

नॉलेज ग्राफ़्स और LLMs को मिलाने के सर्वश्रेष्ठ अभ्यास

KGs, LLMs की क्षमताओं को बढ़ाते हैं और उन्हें व्यावहारिक उपयोग के मामलों के लिए प्रासंगिक बनाते हैं। सर्वोत्तम प्रदर्शन प्राप्त करने के लिए, मैं निम्नलिखित सर्वश्रेष्ठ अभ्यासों की अनुशंसा करता/करती हूँ।

ग्राफ़्स को अद्यतन रखें

KG में वह सूचना रिपॉज़िटरी होती है जिसके आधार पर LLM अपनी प्रतिक्रियाएँ बनाता है। इसलिए, ग्राफ़ डाटाबेस को लगातार नवीनतम जानकारी से अपडेट करना आवश्यक है। पुराना KG, LLM से पुराने उत्तर दिलवाएगा। 

क्वेरी दक्षता का अनुकूलन करें

LLMs और KGs जटिल सॉफ़्टवेयर हैं जिनकी कम्प्यूटेशनल आवश्यकताएँ भारी होती हैं। जैसा कि पिछले अनुभाग में दिखाया गया, LLMs और KGs को चेन करने में कई चरण शामिल हैं—उपयोगकर्ता की क्वेरी को टोकनाइज़ करना, संबंधित ग्राफ़ क्वेरी जनरेट करना, KG से जानकारी पुनर्प्राप्त करना और उससे पाठ जनरेट करना। 

इससे अक्षमताएँ और क्वेरी व प्रतिक्रिया के बीच देरी हो सकती है। नीचे बताए गए अनुकूलन तरीके विलंबता को कम करने में मदद करते हैं। 

• कैशेस बार-बार एक्सेस किए जाने वाले डेटा को हाई-स्पीड मेमोरी यूनिट्स में स्टोर करते हैं। इससे सामान्यतः उपयोग होने वाले परिणामों को फिर से गणना करने की आवश्यकता नहीं रहती।
• क्वेरी परिणाम: की-वैल्यू स्टोर्स का उपयोग KG की सामान्य क्वेरियों के परिणाम सहेजने के लिए किया जा सकता है
• LLM एम्बेडिंग्स: सामान्य इनपुट क्वेरियों के लिए एम्बेडिंग वेक्टर को कैश किया जा सकता है ताकि बार-बार LLM API एक्सेस न करना पड़े। इससे समय और लागत दोनों बचते हैं। 
• क्वेरी ऑप्टिमाइज़ेशन में डाटाबेस क्वेरियों को फिर से लिखना और सही इंडेक्स का उपयोग करना शामिल है, ताकि डाटाबेस एक्सेस अधिक कुशल हो सके। 
• इंडेक्सेज़ ग्राफ़ एलीमेंट्स जैसे नोड्स, रिलेशनशिप्स और उनकी प्रॉपर्टीज़ तक तीव्रता से पहुँचने में मदद करते हैं। सही प्रकार के इंडेक्स (बार-बार उपयोग होने वाले डेटा पर) क्वेरियों और रिलेशनशिप लुकअप्स को तेज़ करते हैं। 
• क्वेरी पैरामीटराइज़ेशन सामान्य क्वेरी संरचनाओं के अनुकूलित और पैरामीटराइज़्ड संस्करण बनाता और कैश करता है, जिसमें उपयोगकर्ता के क्वेरी टर्म्स के लिए प्लेसहोल्डर्स होते हैं। इससे उपयोगकर्ता क्वेरियों को चलाना और लौटाना तेज़ हो जाता है। 
• असिंक्रोनस क्वेरिंग सुनिश्चित करती है कि LLM को KG के उत्तर का इंतज़ार न करना पड़े। LLM कई डाटाबेस क्वेरियाँ जारी कर सकता है और जैसे-जैसे उत्तर लौटते हैं, उनके साथ काम कर सकता है। 
• लोड बैलेंसिंग उपयोगकर्ता क्वेरियों को रेप्लिका डाटाबेस और भाषा मॉडलों में वितरित करने में मदद करता है। पहचानें कि बॉटलनेक LLM है या KG, और उसे क्षैतिज रूप से स्केल करें ताकि अन्य चेन घटक प्रोसेसिंग जारी रख सकें। 

भाषा मॉडलों का आकार घटाएँ

LLMs मेमोरी-हेवी मॉडल होते हैं और अक्सर इन्हें चलाने के लिए महंगे हार्डवेयर की ज़रूरत होती है। LLM Distillation और Quantization जैसी तकनीकों से एआई मॉडलों का आकार घटाना उपयोगी है:

• LLM Distillation एक तकनीक है जिसमें एक छोटा मॉडल, जिसे स्टूडेंट मॉडल कहा जाता है, बड़े (टीचर) मॉडल की प्रतिक्रियाओं की नकल करता है। केवल टीचर मॉडल को मूल डेटासेट पर प्रशिक्षित किया जाता है, और स्टूडेंट मॉडल को केवल बहुत सारे इनपुट्स पर टीचर की प्रतिक्रियाओं से मेल खाने के लिए प्रशिक्षित किया जाता है। इस प्रक्रिया को नॉलेज डिस्टिलेशन कहा जाता है, और यह शून्य से मॉडल ट्रेन करने की तुलना में बहुत सस्ती होती है। हालाँकि, जिन नए प्रश्नों पर इसे प्रशिक्षित नहीं किया गया है, उन पर स्टूडेंट का प्रदर्शन भरोसेमंद न हो सकता है। 
• LLMs का क्वांटाइज़ेशन मॉडल वेट्स की प्रिसीज़न कम करने से संबंधित है। एआई मॉडल की मेमोरी और कम्प्यूटेशनल आवश्यकताओं का अधिकांश भाग मॉडल वेट्स पर बड़े पैमाने के मैट्रिक्स गुणन संचालन के कारण होता है। बेस एआई मॉडलों के वेट्स आमतौर पर 32-बिट या 16-बिट फ़्लोटिंग-पॉइंट नंबर्स के रूप में निरूपित होते हैं। यह देखा गया है कि वेट्स की प्रिसीज़न को 8-बिट इन्टीजर्स (कुछ मामलों में, 1-बिट तक) करने से, आकार और लागत के एक हिस्से में तुलनीय प्रदर्शन मिलता है। 

LLM प्रदर्शन का मूल्यांकन करें

आपको सुनिश्चित करना चाहिए कि चुना हुआ भाषा मॉडल उन प्रकार की क्वेरियों पर अच्छा प्रदर्शन करता है जिन्हें उसे संभालने की अपेक्षा है। 

MLFlow जैसे टूल्स LLM प्रदर्शन का मूल्यांकन करने में मदद करते हैं विभिन्न कार्यों पर। जैसे-जैसे उपयोगकर्ताओं की ज़रूरतें बदलती और विकसित होती हैं, वैसे-वैसे नॉलेज ग्राफ़ में संग्रहीत जानकारी भी समय के साथ बदलती है। इसलिए, डिप्लॉयमेंट के बाद LLM के प्रदर्शन का समय-समय पर पुनर्मूल्यांकन करना आवश्यक है। हो सकता है मॉडल को अद्यतन डेटासेट पर फाइन-ट्यून करना, मॉडल का अद्यतन संस्करण उपयोग करना, या नया मॉडल डिप्लॉय करना ज़रूरी हो। 

डोमेन-विशिष्ट डेटा के साथ LLMs को फाइन-ट्यून करें

LLM को जानकारी KG से मिलती है और भाषा व तर्क क्षमताएँ उसके प्रशिक्षण डेटासेट से। 

बेस मॉडल LLMs विशाल सामान्य डेटासेट्स पर प्रशिक्षित होते हैं, जो आमतौर पर पूरे इंटरनेट के पाठ का उपयोग करते हैं। LLM को किसी डोमेन-विशिष्ट डेटासेट पर फाइन-ट्यून करने से उस डोमेन में इसकी तर्क क्षमताएँ बढ़ती हैं और यह सही संरचना और पारिभाषिक शब्दावली के साथ वाक्य गढ़ने में सक्षम होता है। उदाहरण के लिए, किसी मेडिकल KG का उपयोग करके मेडिकल प्रश्नों का उत्तर देने हेतु, मैं दृढ़ता से अनुशंसा करता/करती हूँ कि बेस LLM को मेडिकल टेक्स्ट्स के डेटासेट पर फाइन-ट्यून किया जाए। 

निष्कर्ष

इस लेख में, हमने बड़े भाषा मॉडल (LLMs) और नॉलेज ग्राफ़्स (KGs) के बुनियादी सिद्धांतों और यह कैसे एक-दूसरे के पूरक हैं, पर चर्चा की। हमने उपयोगकर्ता-उन्मुख एप्लिकेशन बनाने के लिए LLMs और KGs को साथ उपयोग करने में आमतौर पर प्रयुक्त कुछ टूल्स का परिचय भी दिया। अंत में, हमने दिखाया कि LangChain का उपयोग करके Neo4j और OpenAI को साथ में कैसे इस्तेमाल किया जा सकता है।

इन बुनियादी अवधारणाओं को समझने के बाद, आप व्यावहारिक रूप से इन टूल्स को लागू कर सकते हैं:

• पहले चरण के रूप में, Python का उपयोग करके LLMs की परिचयात्मक कोर्स की समीक्षा करें।
• यदि आप LLMs की बुनियाद से पहले से परिचित हैं, तो LangChain के साथ Retrieval Augment Generation (RAG) सिस्टम बनाना देखें।
• अंत में, यदि आप प्रोडक्शन सिस्टम तैनात कर रहे हैं, तो LLMOps की अवधारणाएँ कोर्स पर विचार करें।