Retrieval Augmented Generation (RAG) और Reranking के साथ LLM की सटीकता बढ़ाएँ

कल्पना कीजिए एक Large Language Model (LLM) की, जहाँ आपके उत्तर सिर्फ प्रासंगिक ही नहीं, बल्कि आपकी ज़रूरतों के अनुरूप सावधानी से चुने, प्राथमिकता दिए गए और परिष्कृत हों। LLMs ने AI की दुनिया में क्रांति ला दी है, पर वे सीमाओं से मुक्त नहीं हैं। भ्रम (hallucinations) और डेटा के पुराने पड़ जाने जैसी समस्याएँ उनके आउटपुट की सटीकता और प्रासंगिकता को प्रभावित कर सकती हैं। यहीं पर Retrieval-Augmented Generation (RAG) और reranking काम आते हैं—ऐसे तंत्र जो गतिशील, नवीनतम सूचना पुनर्प्राप्ति प्रक्रियाओं के साथ LLMs को जोड़कर उन्हें बेहतर बनाते हैं। इस “रेसिपी” के चरण जानना चाहते हैं? आगे पढ़ें।

LLMs को बेहतर बनाने के लिए RAG क्यों?

LLMs ने AI के क्षेत्र में क्रांति ला दी है और इसकी क्षमताओं की सीमाएँ आगे बढ़ा दी हैं। प्राकृतिक भाषा की समझ और जनरेशन से जुड़ी कई तरह की जिम्मेदारियाँ निभाकर, वे लगभग हर डोमेन में बहुपयोगी NLP समाधानों के लिए पसंदीदा टूल बन गए हैं, जैसा कि नीचे दिखाया गया है।

LLMs द्वारा हल योग्य भाषा कार्यों का वर्गीकरण | Iván Palomares

क्षमताओं के बावजूद, कुछ परिदृश्यों में LLMs की सीमाएँ भी हैं। उपयोग-केस और उस ज्ञान पर निर्भर करते हुए जो इन्हें विशाल प्रशिक्षण डेटा से मिला है, LLMs कभी-कभी असंगत, अप्रासंगिक, या संदर्भ-विरुद्ध पाठ जनरेट कर देते हैं। कभी-कभी, उपयोगकर्ता के प्रश्न का उत्तर देने के लिए सत्यापनीय प्रासंगिक डेटा न होने पर वे गलत या अर्थहीन जानकारी भी “सच” की तरह बना देते हैं। इस घटना को hallucination कहा जाता है।

उदाहरण के लिए यह प्रश्न लें: "What are the common flu symptoms?"

एक साधारण LLM सामान्य ज्ञान के आधार पर बुखार, खांसी, बदन दर्द जैसे आम लक्षणों की सूची दे सकता है।

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

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

डेटा के इस “पुराने पड़ जाने” की समस्या को knowledge cut-off कहा जाता है।

कई मामलों में, ऊपर बताई समस्या का समाधान LLM को बार-बार नए, अप-टू-डेट डेटा पर फिर से प्रशिक्षित करना और फाइन-ट्यून करना हो सकता है। लेकिन क्या यह हमेशा सबसे अच्छा रास्ता है?

LLMs (Large Language Models) को प्रशिक्षित करना मुश्किल और कंप्यूटेशनल रूप से महंगा माना जाता है। इन्हें लाखों–अरबों पाठ उदाहरणों की जरूरत होती है और फाइन-ट्यूनिंग के लिए अक्सर हज़ारों डोमेन-विशिष्ट टेक्स्ट चाहिए होते हैं (नीचे के आरेख को देखें)।

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

किसी LLM का प्री-ट्रेनिंग और फाइन-ट्यूनिंग | Iván Palomares

यहीं पर RAG (Retrieval Augmented Generation) मदद करता है!

RAG एक सूचना-पुनर्प्राप्ति प्रक्रिया है जिसके जरिए LLM के आउटपुट को अनुकूलित किया जाता है। LLMs उत्तर जनरेट करने के लिए उस ज्ञान पर निर्भर करते हैं जो उन्हें उनके प्रशिक्षण डेटा से मिला है।

वहीं, RAG एक बाहरी नॉलेज बेस की ओर इंगित करता है।

दोनों समाधानों को मिलाकर, RAG पहले बताए गए नॉलेज बेस से ज्ञान निकालकर LLM द्वारा जनरेट किए “कच्चे” आउटपुट की गुणवत्ता, उपयोगकर्ता-प्रासंगिकता, सुसंगति और सत्यता को बढ़ा सकता है।

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

एक RAG सिस्टम के वर्कफ़्लो का सरल विवरण नीचे दिया गया है:

Query: उपयोगकर्ता का क्वेरी या प्रॉम्प्ट LLM द्वारा संगृहीत किया जाता है।
Retrieve: रनटाइम में, LLM एक रिट्रीवल कंपोनेंट तक पहुँचता है जो टेक्स्ट डॉक्युमेंट्स के कॉर्पस को इंडेक्स करता है और उपयोगकर्ता क्वेरी के साथ सर्वोच्च K मैचिंग हिस्से पहचानता है।
Generate: LLM दो सूचनाएँ—मूल उपयोगकर्ता इनपुट और रिट्रीव किए गए डॉक्युमेंट्स—को मिलाकर आउटपुट प्रतिक्रिया बनाता है, और सामान्य तरीके से अधिकतम संभाव्यता सिद्धांत का उपयोग करके आउटपुट अनुक्रम के हर अगले टोकन को जनरेट करता है।

फ्लू वाले उदाहरण पर वापस आएँ, तो RAG के साथ मॉडल मेडिकल डेटाबेस या हालिया लेखों से अप-टू-डेट, प्रासंगिक जानकारी ला सकता है, जिससे मरीज या चिकित्सक के प्रश्न का अधिक सूक्ष्म और सटीक उत्तर बन सके।

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

Reranking क्या है?

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

पहले, शुरुआती डॉक्युमेंट रिट्रीवल पास होता है, जिसमें retriever K प्रासंगिक डॉक्युमेंट्स लाता है। इस चरण में TF-IDF, वेक्टर स्पेस मॉडल आदि जैसे सामान्य तरीके शामिल होते हैं।
दूसरे, शुरुआती retriever से अधिक परिष्कृत या डोमेन-विशिष्ट तंत्र, जिसे ranker कहते हैं, उपयोग में आता है। रैंकर अतिरिक्त मानदंडों—जैसे सीखे हुए उपयोगकर्ता वरीयताएँ, संदर्भ और जरूरतें, या अधिक जटिल एल्गोरिद्म—के आधार पर प्राप्त नतीजों का पुनर्मूल्यांकन करता है। यह द्वितीयक छँटाई खास उपयोगकर्ता के लिए नतीजों की प्रासंगिकता बढ़ाने का लक्ष्य रखती है।

निम्न आरेख reranking प्रक्रिया को दर्शाता है:

Reranking प्रक्रिया | Iván Palomares

यहाँ एक महत्वपूर्ण बात स्पष्ट कर लें: reranking विभिन्न मानदंडों, जैसे उपयोगकर्ता वरीयताओं, के आधार पर रिट्रीव किए गए डॉक्युमेंट्स का क्रम बदलता है। हालाँकि, reranking, recommender इंजनों से अलग है, जैसे ई-कॉमर्स साइटों पर उत्पाद सुझाने वाले इंजन।

Reranking उन सर्च परिदृश्यों में प्रयोग होता है जहाँ उपयोगकर्ता वास्तविक समय में एक इनपुट क्वेरी देता है।

इसके विपरीत, recommender इंजन समय के साथ उपयोगकर्ताओं की अंतःक्रियाओं और वरीयताओं के आधार पर सक्रिय रूप से व्यक्तिगत सुझाव तैयार करते हैं।

फ्लू के उदाहरण पर फिर लौटते हैं।

मान लीजिए कोई स्वास्थ्य पेशेवर "best treatments for flu symptoms." खोजता है। एक शुरुआती रिट्रीवल सिस्टम सामान्य फ्लू जानकारी, उपचार दिशानिर्देश, और शोध लेख सहित डॉक्युमेंट्स की सूची लौटा सकता है।

लेकिन एक reranking मॉडल, संभवतः अतिरिक्त मरीज-विशिष्ट डेटा और संदर्भगत जानकारी का उपयोग करते हुए, इन डॉक्युमेंट्स को फिर से क्रमबद्ध कर सकता है ताकि सबसे प्रासंगिक और नवीनतम उपचार प्रोटोकॉल, रोगी देखभाल सुझाव, और सहकर्मी-समीक्षित अध्ययन, जो सीधे फ्लू लक्षणों और उनके प्रबंधन को संबोधित करते हैं, प्राथमिकता से दिखें—अर्थात् ऐसे नतीजे जो “सीधे मुद्दे पर” हों।

संक्षेप में, reranking अतिरिक्त प्रासंगिकता मानदंडों के आधार पर रिट्रीव किए गए डॉक्युमेंट्स की सूची का पुनर्गठन करता है, ताकि विशिष्ट उपयोगकर्ता के लिए सबसे उपयुक्त सामग्री पहले दिखाई दे।

RAG वाले LLMs के लिए Reranking उपयोगी क्यों है?

Reranking विशेष रूप से उन Large Language Models (LLMs) में उपयोगी है जो Retrieval-Augmented Generation (RAG) से लैस हों। RAG, LLMs को बाहरी डॉक्युमेंट रिट्रीवल के साथ मिलाकर अधिक सूचित और सटीक उत्तर देता है।

क्वेरी के आधार पर शुरुआती डॉक्युमेंट रिट्रीवल के बाद, reranking प्रक्रिया चयन को और परिष्कृत कर सकती है, यह सुनिश्चित करते हुए कि LLM सबसे प्रासंगिक और उच्च-गुणवत्ता वाली जानकारी पर काम करे।

यह प्रक्रिया LLM के समग्र प्रदर्शन को बढ़ाती है—खासकर उन विशिष्ट डोमेन्स में जहाँ सूक्ष्म और सटीक जानकारी महत्वपूर्ण होती है—और प्रतिक्रिया की सटीकता व प्रासंगिकता में सुधार करती है।

Rerankers के प्रकार

किसी reranker को लागू करने के लिए एक ही नुस्खा नहीं है। कई दृष्टिकोण स्थापित हैं, जिनमें से कुछ हैं:

मल्टी-वेक्टर rerankers: इस प्रकार के reranker डॉक्युमेंट्स और उपयोगकर्ता क्वेरियों को एकाधिक वेक्टर अभ्यावेदन सौंपते हैं, और वेक्टर समानता से नतीजों का पुनः क्रम निर्धारित करते हैं।
Learning to Rank (LTR): रिकमेंडर एल्गोरिद्म में व्यापक रूप से लोकप्रिय, LTR मशीन लर्निंग सिद्धांतों और प्रशिक्षण डेटा का उपयोग करके नतीजों की इष्टतम रैंकिंग की भविष्यवाणी करना सीखता है। इनपुट के रूप में डॉक्युमेंट्स की सूची दी जाती है और आउटपुट “सबसे अच्छी” संभव रैंकिंग होता है।
BERT-आधारित rerankers: BERT एक ट्रांसफॉर्मर-आधारित मॉडल है जो टेक्स्ट वर्गीकरण जैसे भाषा-समझ कार्यों में विशेषज्ञ है। Reranking के संदर्भ में, BERT मॉडल रिट्रीव किए गए डॉक्युमेंट्स के सेमान्टिक सूक्ष्म अंतर समझकर उनकी रैंकिंग को परिष्कृत करने में काम आ सकते हैं।
Reinforcement learning rerankers: सतत उपयोगकर्ता-इंटरैक्शन डेटा के आधार पर, एक दीर्घकालिक रिवॉर्ड फ़ंक्शन—जैसे उपयोगकर्ता संतुष्टि—द्वारा निर्देशित रैंकिंग का अनुकूलन करते हैं, जिसे परीक्षण–त्रुटि से धीरे-धीरे सीखा जाता है, ठीक एक reinforcement learning एल्गोरिद्म की तरह।
हाइब्रिड rerankers: ये कई reranking रणनीतियों को मिलाते हैं, जैसे LTR को अनेक संयोजित मशीन लर्निंग या डीप लर्निंग मॉडलों के साथ जोड़ना।

Reranking के साथ RAG पाइपलाइन बनाना

अब जबकि हमने LLMs में RAG शामिल करने के फायदे और नॉलेज रिट्रीवल के लिए reranking तंत्र समझ लिए हैं, तो इन्हें साथ जोड़कर अमल में देखने का समय है।

इस उदाहरण में एक सरल RAG पाइपलाइन को reranking के साथ बनाने के लिए Langchain लाइब्रेरी (कम्युनिटी संस्करण) का उपयोग किया गया है। Langchain के साथ LLM एप्लिकेशन विकसित करने के बारे में और जानें: Developing LLM Applications कोर्स और यह Langchain से LLM एप्लिकेशन बनाने पर ट्यूटोरियल।

कोड एक Google Colab नोटबुक में लागू किया गया है।

Version 1 - बिना reranking के

pip install -U langchain-communityसंचालित द्वारा

सबसे पहले, हम अपने नोटबुक में langchain-community इंस्टॉल करते हैं।

इसके बाद, ज़रूरी पैकेज, क्लास, और फ़ंक्शंस इम्पोर्ट करें।

import os
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.text_splitter import CharacterTextSplitter
from langchain.schema import Document
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from sklearn.metrics.pairwise import cosine_similarity
import numpy as npसंचालित द्वारा

निम्न फ़ंक्शन स्थानीय डायरेक्टरी से डॉक्युमेंट्स (.txt फाइलें) की सूची लोड करने के लिए परिभाषित है, जिससे आपका कोड नोटबुक पढ़ सके। इन्हीं डॉक्युमेंट्स को रिट्रीव और rerank किया जाएगा ताकि LLM आउटपुट बेहतर बने:

# Function to load documents from a directory
def load_documents_from_directory(directory_path):
    documents = []
    for filename in os.listdir(directory_path):
        if filename.endswith(".txt"):
            with open(os.path.join(directory_path, filename), 'r') as file:
                documents.append(file.read())
    return documents

# Load documents from the specified directory
directory_path = "./sample_data"
documents = load_documents_from_directory(directory_path)
संचालित द्वारा

टेक्स्ट डॉक्युमेंट्स के एम्बेडिंग अभ्यावेदन के प्रदर्शन को अनुकूलित करने के लिए, हम उनके आकार को 1000 तक सीमित करते हैं और उससे बड़े डॉक्युमेंट्स को छोटे हिस्सों में बाँटते हैं। CharacterTextSplitter क्लास यह काम करने में मदद करता है।

chunk_overlap आर्ग्युमेंट को 0 रखा गया है ताकि हिस्सों में टेक्स्ट की ओवरलैपिंग न हो।

# Split documents into chunks for better embedding performance
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)
संचालित द्वारा

हम अपने एम्बेडिंग वेक्टर स्टोर के लिए OpenAI embeddings का उपयोग करेंगे। ध्यान दें, जिस वातावरण में आप कोड चला रहे हैं, उसके अनुसार OPENAI_API_KEY में OpenAI से प्राप्त वैलिडेशन की देना पड़ सकता है।

# Initialize OpenAI embeddings
embeddings = OpenAIEmbeddings()

# Build FAISS vector store upong document chunk embeddings
vector_store = FAISS.from_documents(docs, embeddings)

# Load and initialize OpenAI LLM
llm = OpenAI(model="text-davinci-003", temperature=0.7)संचालित द्वारा

FAISS एम्बेडिंग्स से वेक्टर स्टोर बनाता है। हमें इसकी from_documents() फ़ंक्शन को दो आर्ग्युमेंट देने होते हैं: डॉक्युमेंट हिस्से, और OpenAIEmbeddings द्वारा इनिशियलाइज़ किया गया एम्बेडिंग्स इंस्टेंस।

इसके बाद, हम मुख्य पात्रों में से एक—LLM—को मंच पर लाते हैं! हम OpenAI का text-davinci-003 मॉडल लोड करते हैं और मॉडल का तापमान 0.7 सेट करते हैं ताकि टेक्स्ट जनरेशन में कुछ मौलिकता की गुंजाइश रहे।

कुछ और कदम उठाते हैं:

# Define the prompt template for the LLM
prompt_template = PromptTemplate(template="Answer the question based on the context: {context}\n\nQuestion: {question}\nAnswer:")

# Define the RAG chain with reranking using a QA chain
qa_chain = load_qa_with_sources_chain(llm, prompt_template=prompt_template, retriever=vector_store.as_retriever())

# Example question
question = "What are the common symptoms of the flu and how can it be treated?"

# Generate an answer using the QA chain
response = qa_chain(question=question)

print(response)संचालित द्वारा

ऊपर का कोड पहले एक प्रश्न–उत्तर प्रॉम्प्ट टेम्पलेट परिभाषित करता है। फिर load_qa_with_sources_chain() फ़ंक्शन कॉल करके प्रश्न–उत्तर पाइपलाइन (Langchain की शब्दावली में “चेन”) बनाता है। इसका retriever आर्ग्युमेंट LLM पाइपलाइन में रिट्रीवल कंपोनेंट जोड़ने की सुविधा देता है, और इस प्रकार RAG संभव होता है।

अंत में एक प्रश्न गढ़ा जाता है, और हम परिभाषित पाइपलाइन qa_chain चलाते हैं। voila!

यह आउटपुट है (यह इस पर निर्भर करेगा कि आप किन डॉक्युमेंट्स से पढ़ रहे हैं):

“Common symptoms of the flu include fever, cough, sore throat, runny or stuffy nose, body aches, headache, chills, and fatigue. Some people may experience vomiting and diarrhea, particularly children. The flu can be treated with antiviral drugs, which can make the illness milder and shorten the duration of sickness. Antiviral drugs may also prevent serious complications such as pneumonia. Prompt treatment is recommended for individuals who are very sick or at high risk of complications.”

Version 2 - reranking के साथ

पिछला उदाहरण अच्छा था, सिवाय इसके कि उसमें reranking चरण शामिल नहीं था। कोड में बदलाव करके reranking जोड़ना अपेक्षाकृत सीधा है।

इम्पोर्ट्स की सूची वही है, क्योंकि पिछली संस्करण में हमने reranking चरण के लिए आवश्यक सभी इम्पोर्ट्स कर लिए थे—भले ही हमने उनमें से कुछ का अब तक उपयोग न किया हो:

# Previous code here
#...

# Define the prompt template for the LLM
prompt_template = PromptTemplate(template="Answer the question based on the context: {context}\n\nQuestion: {question}\nAnswer:")

# Reranking function
def rerank_documents(question, retrieved_docs, top_n=5):
    question_embedding = embeddings.embed_text(question)
    doc_embeddings = [doc.embedding for doc in retrieved_docs]
    similarities = cosine_similarity([question_embedding], doc_embeddings)[0]
    
    ranked_indices = np.argsort(similarities)[::-1]  # Sort by descending similarity
    ranked_docs = [retrieved_docs[i] for i in ranked_indices[:top_n]]
    return ranked_docsसंचालित द्वारा

जैसा कि दिखता है, हम पहले rerank_documents फ़ंक्शन परिभाषित करते हैं, जो एम्बेडिंग्स पर कोसाइन समानता का उपयोग करके प्रश्न और डॉक्युमेंट एम्बेडिंग्स के बीच समानता निकालता है और शीर्ष-n रैंक किए डॉक्युमेंट्स लौटाता है।

# Custom QA chain with reranking
class CustomQAWithReranking:
    def __init__(self, llm, retriever, prompt_template, top_n=5):
        self.llm = llm
        self.retriever = retriever
        self.prompt_template = prompt_template
        self.top_n = top_n

    def __call__(self, question):
        retrieved_docs = self.retriever.retrieve_documents(question)
        ranked_docs = rerank_documents(question, retrieved_docs, self.top_n)
        context = "\n".join([doc.page_content for doc in ranked_docs])
        prompt = self.prompt_template.format(context=context, question=question)
        return self.llm(prompt)संचालित द्वारा

CustomQAWithReranking क्लास LLM पाइपलाइन में रिट्रीवल और reranking दोनों चरणों को एकीकृत करता है, जिसे इस क्लास के call () फ़ंक्शन को कॉल करके चलाया जाएगा।

# Define the custom QA chain with reranking
qa_chain = CustomQAWithReranking(llm, vector_store.as_retriever(), prompt_template)

# Example question
question = "What are the benefits of using multi-vector rerankers?"

# Generate an answer using the custom QA chain
response = qa_chain(question)संचालित द्वारा

अब बस फिर से qa_chain को इंस्टैंशिएट करना रह गया है। ध्यान दें, इस बार हम इसे अभी-अभी बनाई क्लास के ऑब्जेक्ट के रूप में परिभाषित करेंगे, जो हमारी पिछली संस्करण की अधिकांश लॉजिक के साथ हमारा कस्टम reranking तंत्र समेटता है।

अंत में, हम प्रश्न बनाते हैं और चेन को कॉल करके प्रतिक्रिया प्राप्त करते हैं।

AI के बारे में और जानें

LLMs और समग्र AI के क्षेत्र में, RAG संभवतः स्थायी रूप से जगह बना चुका है। उत्तर जनरेट करने की प्रक्रिया के हिस्से के रूप में किसी LLM द्वारा बाहरी स्रोतों से ज्ञान तक पहुँच बनाना और उसे रिट्रीव करना, LLMs के निरंतर रिट्रेनिंग और फाइन-ट्यूनिंग का व्यापक रूप से स्वीकृत विकल्प बन गया है।

इस लेख में LLM पाइपलाइन का हिस्सा बनकर प्रभावी सूचना-पुनर्प्राप्ति को शामिल करने के उपयोगी तरीके के रूप में reranking पर चर्चा की गई। इसमें reranking प्रक्रिया कैसे काम करती है, rerankers के अलग-अलग प्रकार, और Langchain व OpenAI API का उपयोग करते हुए एक व्यावहारिक उदाहरण उजागर किया गया।

और सीखने में रुचि है? इन अतिरिक्त संसाधनों पर नज़र डालें:

लेखक

Iván Palomares Carrascosa

AI और LLMs विशेषज्ञ तथा दूरदर्शी नेतृत्वकर्ता। प्रशिक्षक। शैक्षणिक नेता/निदेशक। AI प्रोजेक्ट प्रबंधन, शिक्षण और नवाचार के प्रवक्ता।

विषय

कृत्रिम बुद्धिमत्ता

प्रौद्योगिकियाँ

विषय

Retrieval Augmented Generation (RAG) और Reranking के साथ LLM की सटीकता बढ़ाएँ

AI के साथ खोजें

LLMs को बेहतर बनाने के लिए RAG क्यों?

Reranking क्या है?

RAG वाले LLMs के लिए Reranking उपयोगी क्यों है?

Rerankers के प्रकार

Reranking के साथ RAG पाइपलाइन बनाना

Version 1 - बिना reranking के

Version 2 - reranking के साथ

AI के बारे में और जानें

विषय

LLMs के बारे में और जानें

Large Language Models (LLMs) कॉन्सेप्ट्स

LangChain के साथ LLM एप्लिकेशन विकसित करना

बड़े भाषा मॉडल विकसित करना

प्रौद्योगिकियाँ

विषय

LLMs के बारे में और जानें

Large Language Models (LLMs) कॉन्सेप्ट्स

LangChain के साथ LLM एप्लिकेशन विकसित करना

बड़े भाषा मॉडल विकसित करना