Vertex AI की मदद से RAG सिस्टम का आकलन करना

1. खास जानकारी

इस लैब में, आपको Retrieval-Augmented Generation (RAG) सिस्टम के लिए, आकलन पाइपलाइन बनाने का तरीका बताया जाएगा. जवाबों का आकलन करने के लिए, Vertex AI Gen AI Evaluation Service का इस्तेमाल किया जाएगा. इससे, आकलन के लिए अपनी ज़रूरत के हिसाब से मानदंड बनाए जा सकेंगे. साथ ही, सवालों के जवाब देने से जुड़े टास्क के लिए, आकलन का फ़्रेमवर्क तैयार किया जा सकेगा.

आपको मूल्यांकन डेटासेट तैयार करने, बिना किसी रेफ़रंस के और रेफ़रंस के आधार पर आकलन कॉन्फ़िगर करने, और नतीजों की व्याख्या करने के लिए, स्टैनफ़ोर्ड क्वेश्चन आंसरिंग डेटासेट (SQuAD 2.0) के उदाहरणों का इस्तेमाल करना होगा. इस लैब के आखिर तक, आपको यह समझ आ जाएगा कि RAG सिस्टम का आकलन कैसे किया जाता है और आकलन के कुछ तरीकों को क्यों चुना जाता है.

डेटासेट फ़ाउंडेशन

हम SQuAD 2.0 Question Answering Dataset में मौजूद, अलग-अलग डोमेन के उदाहरणों पर काम करेंगे:

  • न्यूरोसाइंस: वैज्ञानिक संदर्भों में तकनीकी सटीकता की जांच करना
  • इतिहास: ऐतिहासिक तथ्यों के सटीक होने का आकलन करना
  • भूगोल: इसमें किसी इलाके और राजनीति के बारे में जानकारी का आकलन किया जाता है

इस विविधता से, आपको यह समझने में मदद मिलती है कि अलग-अलग विषयों के लिए, आकलन के तरीके किस तरह सामान्य होते हैं.

रेफ़रंस

आपको क्या सीखने को मिलेगा

इस लैब में, आपको ये टास्क करने का तरीका बताया जाएगा:

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

2. प्रोजेक्ट सेटअप करना

Google खाता

अगर आपके पास पहले से कोई निजी Google खाता नहीं है, तो आपको Google खाता बनाना होगा.

ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.

Google Cloud Console में साइन इन करना

किसी निजी Google खाते का इस्तेमाल करके, Google Cloud Console में साइन इन करें.

बिलिंग चालू करें

Google Cloud क्रेडिट रिडीम करना (ज़रूरी नहीं है)

इस वर्कशॉप को चलाने के लिए, आपके पास कुछ क्रेडिट वाला बिलिंग खाता होना चाहिए. शुरू करने के लिए, इस कोडलैब के सबसे ऊपर मौजूद बैनर में दिए गए क्रेडिट का इस्तेमाल करें. अगर आपका खाता पहले से ही किसी बिलिंग खाते से कनेक्ट है, तो इस चरण को छोड़ा जा सकता है.

निजी बिलिंग खाता सेट अप करना

अगर आपने Google Cloud क्रेडिट का इस्तेमाल करके बिलिंग सेट अप की है, तो इस चरण को छोड़ें.

निजी बिलिंग खाता सेट अप करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करने के लिए यहां जाएं.

ध्यान दें:

  • इस लैब को पूरा करने में, Cloud संसाधनों पर 1 डॉलर से कम खर्च आना चाहिए.
  • ज़्यादा शुल्क से बचने के लिए, संसाधनों को मिटाने का तरीका जानने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करें.
  • नए उपयोगकर्ता, 300 डॉलर के मुफ़्त में आज़माने की सुविधा का फ़ायदा पा सकते हैं.

प्रोजेक्ट बनाना (ज़रूरी नहीं)

अगर आपको इस लैब के लिए किसी मौजूदा प्रोजेक्ट का इस्तेमाल नहीं करना है, तो यहां नया प्रोजेक्ट बनाएं.

3. रीट्रिवल ऑगमेंटेड जनरेशन (आरएजी) क्या है?

आरएजी एक ऐसी तकनीक है जिसका इस्तेमाल, लार्ज लैंग्वेज मॉडल (एलएलएम) से मिले जवाबों को ज़्यादा सटीक और काम का बनाने के लिए किया जाता है. यह एलएलएम को बाहरी नॉलेज बेस से कनेक्ट करता है, ताकि वह जवाबों में खास और पुष्टि की जा सकने वाली जानकारी दे सके.

इस प्रोसेस में ये चरण शामिल हैं:

  1. उपयोगकर्ता के सवाल को संख्यात्मक रूप में बदलना (एम्बेड करना).
  2. नॉलेज बेस में, मिलती-जुलती एम्बेडिंग वाले दस्तावेज़ खोजे जा रहे हैं.
  3. जवाब जनरेट करने के लिए, एलएलएम को ओरिजनल सवाल के साथ-साथ, काम के इन दस्तावेज़ों को कॉन्टेक्स्ट के तौर पर उपलब्ध कराना.

RAG के बारे में ज़्यादा जानें.

RAG के आकलन को मुश्किल बनाने वाली चीज़ें क्या हैं?

आरएजी सिस्टम का आकलन करना, पारंपरिक भाषा मॉडल का आकलन करने से अलग होता है.

मल्टी-कॉम्पोनेंट चुनौती: RAG सिस्टम, तीन ऑपरेशन को एक साथ जोड़ते हैं. इनमें से हर ऑपरेशन में गड़बड़ी हो सकती है:

  • जानकारी पाने की क्वालिटी: क्या सिस्टम को सही कॉन्टेक्स्ट वाले दस्तावेज़ मिले?
  • कॉन्टेक्स्ट का इस्तेमाल: क्या मॉडल ने खोजे गए कॉन्टेक्स्ट का सही तरीके से इस्तेमाल किया है?
  • जनरेट किए गए जवाब की क्वालिटी: क्या जवाब को सही तरीके से लिखा गया है? क्या यह मददगार और सटीक है?

अगर इनमें से कोई भी कॉम्पोनेंट उम्मीद के मुताबिक काम नहीं करता है, तो जवाब नहीं मिल सकता. उदाहरण के लिए, ऐसा हो सकता है कि सिस्टम सही कॉन्टेक्स्ट को वापस ले आए, लेकिन मॉडल उसे अनदेखा कर दे. इसके अलावा, ऐसा भी हो सकता है कि मॉडल ने अच्छी तरह से लिखा गया जवाब जनरेट किया हो, लेकिन वह गलत हो. ऐसा इसलिए, क्योंकि खोजा गया कॉन्टेक्स्ट काम का नहीं था.

4. Vertex AI Workbench एनवायरमेंट सेट अप करना

आइए, हम एक नया नोटबुक एनवायरमेंट शुरू करते हैं. इसमें हम RAG सिस्टम का आकलन करने के लिए ज़रूरी कोड चलाएंगे.

  1. Cloud Console के एपीआई और सेवाएं पेज पर जाएं.
  2. Vertex AI API के लिए, चालू करें पर क्लिक करें. Vertex डैशबोर्ड

Vertex AI Workbench ऐक्सेस करना

  1. Google Cloud Console में, नेविगेशन मेन्यू ☰ > Vertex AI > Workbench पर क्लिक करके, Vertex AI पर जाएं.
  2. नया वर्कबेंच इंस्टेंस बनाएं.Workbench बनाना
  3. वर्कबेंच इंस्टेंस को नाम दें evaluation-workbench.
  4. अगर ये वैल्यू पहले से सेट नहीं हैं, तो अपना क्षेत्र और ज़ोन चुनें.
  5. बनाएं पर क्लिक करें.Workbench का नाम
  6. वर्कबेंच के सेट अप होने का इंतज़ार करें. इसमें कुछ मिनट लग सकते हैं.Await Workbench
  7. वर्कबेंच उपलब्ध होने के बाद, open jupyterlab पर क्लिक करें.Workbench खोलें
  8. वर्कबेंच में, नई Python3 नोटबुक बनाएं.नोटबुक बनाएँ

इस एनवायरमेंट की सुविधाओं और क्षमताओं के बारे में ज़्यादा जानने के लिए, Vertex AI Workbench का आधिकारिक दस्तावेज़ देखें.

Vertex AI Evaluation SDK इंस्टॉल करना

अब हम खास तौर पर तैयार किया गया ऐसा एसडीके इंस्टॉल करते हैं जो आरएजी का आकलन करने के लिए टूल उपलब्ध कराता है.

  1. Vertex AI SDK (साथ ही, आकलन करने वाले कॉम्पोनेंट) को इंस्टॉल करने के लिए, अपनी नोटबुक की पहली सेल में नीचे दिए गए इंपोर्ट स्टेटमेंट को जोड़ें और चलाएं (SHIFT+ENTER).
    %pip install --upgrade --user --quiet google-cloud-aiplatform[evaluation]
    इससे, Vertex AI SDK के साथ-साथ आकलन एक्सटेंशन भी इंस्टॉल हो जाते हैं. इनमें ये शामिल हैं:
    • EvalTask: यह आकलन करने वाली मुख्य क्लास है
    • MetricPromptTemplateExamples: पहले से तय की गई आकलन मेट्रिक
    • PointwiseMetric: कस्टम मेट्रिक बनाने के लिए फ़्रेमवर्क
    • notebook_utils: नतीजों का विश्लेषण करने के लिए विज़ुअलाइज़ेशन टूल
  2. अहम जानकारी: इंस्टॉल करने के बाद, नए पैकेज इस्तेमाल करने के लिए आपको कर्नल को रीस्टार्ट करना होगा. JupyterLab विंडो में सबसे ऊपर मौजूद मेन्यू बार में, Kernel > Restart Kernel पर जाएं.

5. एसडीके को शुरू करना और लाइब्रेरी इंपोर्ट करना

इवैलुएशन पाइपलाइन बनाने से पहले, आपको अपना एनवायरमेंट सेट अप करना होगा. इसमें, प्रोजेक्ट की जानकारी कॉन्फ़िगर करना, Google Cloud से कनेक्ट करने के लिए Vertex AI SDK को शुरू करना, और उन खास Python लाइब्रेरी को इंपोर्ट करना शामिल है जिनका इस्तेमाल आपको आकलन के लिए करना है.

  1. आकलन के काम के लिए, कॉन्फ़िगरेशन वैरिएबल तय करें. इस रन को व्यवस्थित करने के लिए, नई सेल में यह कोड जोड़ें और चलाएं. इससे PROJECT_ID, LOCATION, और EXPERIMENT का नाम सेट किया जा सकेगा.
    import vertexai

PROJECT_ID = "YOUR PROJECT ID"
LOCATION = "YOUR LOCATION"  # @param {type:"string"}
EXPERIMENT = "rag-eval-01"  # @param {type:"string"}

if not PROJECT_ID or PROJECT_ID == "[your-project-id]":
    raise ValueError("Please set your PROJECT_ID")
  2. Vertex AI SDK को शुरू करें. नई सेल में, यह कोड जोड़ें और चलाएं.
    vertexai.init(project=PROJECT_ID, location=LOCATION)
    इस चरण में, आपकी नोटबुक की पुष्टि की जाती है और उसे आपके Google Cloud प्रोजेक्ट से कनेक्ट किया जाता है.
  3. अगली सेल में यह कोड चलाकर, आकलन एसडीके से ज़रूरी क्लास इंपोर्ट करें:
    import pandas as pd
from vertexai.evaluation import EvalTask, MetricPromptTemplateExamples, PointwiseMetric
from vertexai.preview.evaluation import notebook_utils
    यहां हर इंपोर्ट की खास जानकारी दी गई है:
    • pandas: इसका इस्तेमाल, DataFrames में डेटा बनाने और उसे मैनेज करने के लिए किया जाता है.
    • EvalTask: यह मुख्य क्लास है, जो आकलन का काम करती है.
    • MetricPromptTemplateExamples: इससे Google की पहले से तय की गई आकलन मेट्रिक का ऐक्सेस मिलता है.
    • PointwiseMetric: यह आपके हिसाब से कस्टम मेट्रिक बनाने का फ़्रेमवर्क है.
    • notebook_utils: नतीजों को विज़ुअलाइज़ करने के लिए टूल का कलेक्शन.

6. आकलन के लिए डेटासेट तैयार करना

किसी भी भरोसेमंद आकलन के लिए, अच्छी तरह से स्ट्रक्चर किया गया डेटासेट ज़रूरी होता है. आरएजी सिस्टम के लिए, आपके डेटासेट में हर उदाहरण के लिए दो मुख्य फ़ील्ड होने चाहिए:

  • प्रॉम्प्ट: यह लैंग्वेज मॉडल को दिया गया कुल इनपुट है. आपको उपयोगकर्ता के सवाल को अपने RAG सिस्टम (prompt = User Question + Retrieved Context) से मिले कॉन्टेक्स्ट के साथ जोड़ना होगा. यह इसलिए ज़रूरी है, ताकि आकलन करने वाली सेवा को पता चल सके कि मॉडल ने जवाब बनाने के लिए किस जानकारी का इस्तेमाल किया है.
  • जवाब: यह आपके आरएजी मॉडल का जनरेट किया गया फ़ाइनल जवाब है.

आंकड़ों के हिसाब से भरोसेमंद नतीजे पाने के लिए, करीब 100 उदाहरणों का डेटासेट इस्तेमाल करने का सुझाव दिया जाता है. इस लैब के लिए, प्रोसेस दिखाने के लिए छोटे डेटासेट का इस्तेमाल किया जाएगा.

आइए, डेटासेट बनाते हैं. आपको RAG सिस्टम से, सवालों की सूची और retrieved_contexts मिलेगा. इसके बाद, आपको जवाबों के दो सेट तय करने होंगे: एक ऐसे मॉडल से जो अच्छा परफ़ॉर्म करता है (generated_answers_by_rag_a) और दूसरा ऐसे मॉडल से जो खराब परफ़ॉर्म करता है (generated_answers_by_rag_b).

आखिर में, ऊपर बताए गए स्ट्रक्चर के मुताबिक, इन हिस्सों को दो pandas DataFrames, eval_dataset_rag_a और eval_dataset_rag_b में जोड़ा जाएगा.

  1. नई सेल में, सवालों और जनरेट किए गए जवाबों के दो सेट तय करने के लिए, यह कोड जोड़ें और चलाएं.
    questions = [
    "Which part of the brain does short-term memory seem to rely on?",
    "What provided the Roman senate with exuberance?",
    "What area did the Hasan-jalalians command?",
]

generated_answers_by_rag_a = [
    "frontal lobe and the parietal lobe",
    "The Roman Senate was filled with exuberance due to successes against Catiline.",
    "The Hasan-Jalalians commanded the area of Syunik and Vayots Dzor.",
]

generated_answers_by_rag_b = [
    "Occipital lobe",
    "The Roman Senate was subdued because they had food poisoning.",
    "The Galactic Empire commanded the state of Utah.",
]
    इससे आपके डेटासेट के मुख्य कॉम्पोनेंट तय होते हैं: सवाल, हर सवाल के लिए आरएजी सिस्टम से वापस पाए गए लंबे कॉन्टेक्स्ट पैसेज, और दो अलग-अलग मॉडल (बेहतर परफ़ॉर्म करने वाला मॉडल A और खराब परफ़ॉर्म करने वाला मॉडल B) से जनरेट किए गए जवाब.
  2. retrieved_contexts को तय करें. नई सेल में यहां दिया गया कोड जोड़ें और चलाएं.
    retrieved_contexts = [
    "Short-term memory is supported by transient patterns of neuronal communication, dependent on regions of the frontal lobe (especially dorsolateral prefrontal cortex) and the parietal lobe. Long-term memory, on the other hand, is maintained by more stable and permanent changes in neural connections widely spread throughout the brain. The hippocampus is essential (for learning new information) to the consolidation of information from short-term to long-term memory, although it does not seem to store information itself. Without the hippocampus, new memories are unable to be stored into long-term memory, as learned from patient Henry Molaison after removal of both his hippocampi, and there will be a very short attention span. Furthermore, it may be involved in changing neural connections for a period of three months or more after the initial learning.",
    "In 62 BC, Pompey returned victorious from Asia. The Senate, elated by its successes against Catiline, refused to ratify the arrangements that Pompey had made. Pompey, in effect, became powerless. Thus, when Julius Caesar returned from a governorship in Spain in 61 BC, he found it easy to make an arrangement with Pompey. Caesar and Pompey, along with Crassus, established a private agreement, now known as the First Triumvirate. Under the agreement, Pompey's arrangements would be ratified. Caesar would be elected consul in 59 BC, and would then serve as governor of Gaul for five years. Crassus was promised a future consulship.",
    "The Seljuk Empire soon started to collapse. In the early 12th century, Armenian princes of the Zakarid noble family drove out the Seljuk Turks and established a semi-independent Armenian principality in Northern and Eastern Armenia, known as Zakarid Armenia, which lasted under the patronage of the Georgian Kingdom. The noble family of Orbelians shared control with the Zakarids in various parts of the country, especially in Syunik and Vayots Dzor, while the Armenian family of Hasan-Jalalians controlled provinces of Artsakh and Utik as the Kingdom of Artsakh.",
]
    अब आपके पास सभी रॉ कॉम्पोनेंट हैं. अब आपको इन्हें स्ट्रक्चर्ड पांडा डेटाफ़्रेम में जोड़ना होगा. ये डेटाफ़्रेम, आकलन सेवा के लिए ज़रूरी होते हैं.
  3. नई सेल में, eval_dataset_rag_a और eval_dataset_rag_b बनाने के लिए, यह कोड जोड़ें और चलाएं.
    eval_dataset_rag_a = pd.DataFrame(
    {
    "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
    ],
    "response": generated_answers_by_rag_a,
    }
)

eval_dataset_rag_b = pd.DataFrame(
    {
    "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
    ],
    "response": generated_answers_by_rag_b,
    }
)
  4. मॉडल A के डेटासेट की शुरुआती कुछ पंक्तियां देखने के लिए, नई सेल में यह कोड चलाएं.
    eval_dataset_rag_a
    इससे यह पक्का किया जा सकता है कि इसे सही तरीके से बनाया गया है.

7. मेट्रिक चुनना और बनाना

डेटासेट तैयार हो जाने के बाद, यह तय किया जा सकता है कि परफ़ॉर्मेंस को कैसे मेज़र किया जाए. अपने मॉडल का आकलन करने के लिए, एक या उससे ज़्यादा मेट्रिक का इस्तेमाल किया जा सकता है. हर मेट्रिक, मॉडल के जवाब के किसी पहलू का आकलन करती है. जैसे, जवाब में दी गई जानकारी सही है या नहीं या वह क्वेरी के हिसाब से है या नहीं.

दो तरह की मेट्रिक का इस्तेमाल किया जा सकता है:

  • पहले से तय की गई मेट्रिक: ये मेट्रिक, SDK टूल के साथ पहले से उपलब्ध होती हैं. इनका इस्तेमाल, सामान्य आकलन के लिए किया जाता है.
  • कस्टम मेट्रिक: ये ऐसी मेट्रिक होती हैं जिन्हें आपने अपने इस्तेमाल के उदाहरण के हिसाब से तय किया है.

इस सेक्शन में, आपको RAG के लिए पहले से तय की गई मेट्रिक के बारे में जानकारी मिलेगी.

पहले से तय की गई मेट्रिक एक्सप्लोर करना

एसडीके में, सवाल-जवाब वाले सिस्टम का आकलन करने के लिए कई बिल्ट-इन मेट्रिक शामिल होती हैं. ये मेट्रिक, लैंग्वेज मॉडल का इस्तेमाल "इवैल्यूएटर" के तौर पर करती हैं. इससे निर्देशों के सेट के आधार पर, आपके मॉडल के जवाबों को स्कोर किया जाता है.

  1. पहले से तय किए गए मेट्रिक के नामों की पूरी सूची देखने के लिए, नई सेल में यह कोड जोड़ें और चलाएं:
    MetricPromptTemplateExamples.list_example_metric_names()
    इससे, उपलब्ध मेट्रिक की सूची मिलती है. इनका इस्तेमाल तुरंत किया जा सकता है.
  2. इन मेट्रिक के काम करने का तरीका समझने के लिए, इनके मूल प्रॉम्प्ट टेंप्लेट की जांच की जा सकती है. नई सेल में, question_answering_quality मेट्रिक के लिए, आकलन करने वाले एलएलएम को दिए गए निर्देश देखने के लिए, यह कोड जोड़ें और चलाएं.
    # See the prompt example for one of the pointwise metrics
print(MetricPromptTemplateExamples.get_prompt_template("question_answering_quality"))

8. कस्टम मेट्रिक बनाएं

पहले से तय की गई मेट्रिक के अलावा, अपने इस्तेमाल के उदाहरण से जुड़ी शर्तों का आकलन करने के लिए, कस्टम मेट्रिक बनाई जा सकती हैं. कस्टम मेट्रिक बनाने के लिए, एक प्रॉम्प्ट टेंप्लेट लिखा जाता है. इसमें, जवाब का स्कोर तय करने के लिए, LLM को निर्देश दिए जाते हैं.

कस्टम मेट्रिक बनाने की प्रोसेस दो चरणों में होती है:

  1. प्रॉम्प्ट टेंप्लेट तय करें: यह एक स्ट्रिंग होती है, जिसमें एलएलएम का आकलन करने वाले व्यक्ति के लिए निर्देश शामिल होते हैं. अच्छे टेंप्लेट में, भूमिका, आकलन के मानदंड, स्कोरिंग रूब्रिक, और {prompt} और {response} जैसे प्लेसहोल्डर शामिल होते हैं.
  2. PointwiseMetric ऑब्जेक्ट को इंस्टैंशिएट करना: इस क्लास में, प्रॉम्प्ट टेंप्लेट स्ट्रिंग को रैप करें और अपनी मेट्रिक को कोई नाम दें.

आपको दो कस्टम मेट्रिक बनानी होंगी. इनकी मदद से, RAG सिस्टम के जवाबों की काम की जानकारी और मददगार होने का आकलन किया जा सकेगा.

  1. मिलते-जुलते होने की मेट्रिक के लिए प्रॉम्प्ट टेंप्लेट तय करें. इस टेंप्लेट में, आकलन करने वाले एलएलएम के लिए रूब्रिक के बारे में पूरी जानकारी दी गई है. नई सेल में, यह कोड जोड़ें और चलाएं:
    relevance_prompt_template = """
You are a professional writing evaluator. Your job is to score writing responses according to pre-defined evaluation criteria.

You will be assessing relevance, which measures the ability to respond with relevant information when given a prompt.

You will assign the writing response a score from 5, 4, 3, 2, 1, following the rating rubric and evaluation steps.

## Criteria
Relevance: The response should be relevant to the instruction and directly address the instruction.

## Rating Rubric
5 (completely relevant): Response is entirely relevant to the instruction and provides clearly defined information that addresses the instruction's core needs directly.
4 (mostly relevant): Response is mostly relevant to the instruction and addresses the instruction mostly directly.
3 (somewhat relevant): Response is somewhat relevant to the instruction and may address the instruction indirectly, but could be more relevant and more direct.
2 (somewhat irrelevant): Response is minimally relevant to the instruction and does not address the instruction directly.
1 (irrelevant): Response is completely irrelevant to the instruction.

## Evaluation Steps
STEP 1: Assess relevance: is response relevant to the instruction and directly address the instruction?
STEP 2: Score based on the criteria and rubrics.

Give step by step explanations for your scoring, and only choose scores from 5, 4, 3, 2, 1.


# User Inputs and AI-generated Response
## User Inputs
### Prompt
{prompt}

## AI-generated Response
{response}
"""
  2. इसी तरीके का इस्तेमाल करके, 'कितना मददगार' मेट्रिक के लिए प्रॉम्प्ट टेंप्लेट तय करें. नई सेल में यह कोड जोड़ें और चलाएं:
    helpfulness_prompt_template = """
You are a professional writing evaluator. Your job is to score writing responses according to pre-defined evaluation criteria.

You will be assessing helpfulness, which measures the ability to provide important details when answering a prompt.

You will assign the writing response a score from 5, 4, 3, 2, 1, following the rating rubric and evaluation steps.

## Criteria
Helpfulness: The response is comprehensive with well-defined key details. The user would feel very satisfied with the content in a good response.

## Rating Rubric
5 (completely helpful): Response is useful and very comprehensive with well-defined key details to address the needs in the instruction and usually beyond what explicitly asked. The user would feel very satisfied with the content in the response.
4 (mostly helpful): Response is very relevant to the instruction, providing clearly defined information that addresses the instruction's core needs.  It may include additional insights that go slightly beyond the immediate instruction.  The user would feel quite satisfied with the content in the response.
3 (somewhat helpful): Response is relevant to the instruction and provides some useful content, but could be more relevant, well-defined, comprehensive, and/or detailed. The user would feel somewhat satisfied with the content in the response.
2 (somewhat unhelpful): Response is minimally relevant to the instruction and may provide some vaguely useful information, but it lacks clarity and detail. It might contain minor inaccuracies. The user would feel only slightly satisfied with the content in the response.
1 (unhelpful): Response is useless/irrelevant, contains inaccurate/deceptive/misleading information, and/or contains harmful/offensive content. The user would feel not at all satisfied with the content in the response.

## Evaluation Steps
STEP 1: Assess comprehensiveness: does the response provide specific, comprehensive, and clearly defined information for the user needs expressed in the instruction?
STEP 2: Assess relevance: When appropriate for the instruction, does the response exceed the instruction by providing relevant details and related information to contextualize content and help the user better understand the response.
STEP 3: Assess accuracy: Is the response free of inaccurate, deceptive, or misleading information?
STEP 4: Assess safety: Is the response free of harmful or offensive content?

Give step by step explanations for your scoring, and only choose scores from 5, 4, 3, 2, 1.


# User Inputs and AI-generated Response
## User Inputs
### Prompt
{prompt}

## AI-generated Response
{response}
"""
  3. अपनी दो कस्टम मेट्रिक के लिए PointwiseMetric ऑब्जेक्ट इंस्टैंशिएट करें. इससे आपके प्रॉम्प्ट टेंप्लेट, ऐसे कॉम्पोनेंट में रैप हो जाते हैं जिन्हें दोबारा इस्तेमाल किया जा सकता है. नई सेल में यह कोड जोड़ें और चलाएं:
    relevance = PointwiseMetric(
    metric="relevance",
    metric_prompt_template=relevance_prompt_template,
)

helpfulness = PointwiseMetric(
    metric="helpfulness",
    metric_prompt_template=helpfulness_prompt_template,
)

अब आपके पास दो नई, फिर से इस्तेमाल की जा सकने वाली मेट्रिक (relevance और helpfulness) हैं. इनका इस्तेमाल, परफ़ॉर्मेंस का आकलन करने के लिए किया जा सकता है.

9. इवैलुएशन जॉब चलाना

डेटासेट और मेट्रिक तैयार हो जाने के बाद, आकलन किया जा सकता है. इसके लिए, आपको हर उस डेटासेट के लिए एक EvalTask ऑब्जेक्ट बनाना होगा जिसकी आपको जांच करनी है.

EvalTask में, आकलन के लिए कॉम्पोनेंट बंडल किए जाते हैं:

  • dataset: यह DataFrame है, जिसमें आपके प्रॉम्प्ट और जवाब शामिल होते हैं.
  • metrics: यह उन मेट्रिक की सूची होती है जिनके आधार पर आपको स्कोर करना है.
  • experiment: यह Vertex AI एक्सपेरिमेंट है, जिसमें नतीजों को लॉग किया जाता है. इससे आपको रन को ट्रैक करने और उनकी तुलना करने में मदद मिलती है.
  1. हर मॉडल के लिए एक EvalTask बनाएं. इस ऑब्जेक्ट में डेटासेट, मेट्रिक, और एक्सपेरिमेंट का नाम शामिल होता है. टास्क कॉन्फ़िगर करने के लिए, नई सेल में यह कोड जोड़ें और चलाएं:
    rag_eval_task_rag_a = EvalTask(
    dataset=eval_dataset_rag_a,
    metrics=[
        "question_answering_quality",
        relevance,
        helpfulness,
        "groundedness",
        "safety",
        "instruction_following",
    ],
    experiment=EXPERIMENT,
)

rag_eval_task_rag_b = EvalTask(
    dataset=eval_dataset_rag_b,
    metrics=[
        "question_answering_quality",
        relevance,
        helpfulness,
        "groundedness",
        "safety",
        "instruction_following",
    ],
    experiment=EXPERIMENT,
)
    अब आपने दो EvalTask ऑब्जेक्ट कॉन्फ़िगर कर लिए हैं. हर ऑब्जेक्ट, मॉडल के जवाबों के एक सेट के लिए है. आपने जो metrics सूची दी है उससे, आकलन सेवा की एक मुख्य सुविधा के बारे में पता चलता है: पहले से तय की गई मेट्रिक (जैसे, safety) और कस्टम PointwiseMetric ऑब्जेक्ट.
  2. टास्क कॉन्फ़िगर करने के बाद, उन्हें .evaluate() तरीके का इस्तेमाल करके पूरा करें. इससे टास्क, प्रोसेस करने के लिए Vertex AI बैकएंड को भेजे जाते हैं. इस प्रोसेस को पूरा होने में कुछ समय लग सकता है. नई सेल में, यह कोड जोड़ें और चलाएं:
    result_rag_a = rag_eval_task_rag_a.evaluate()
result_rag_b = rag_eval_task_rag_b.evaluate()

समीक्षा पूरी होने के बाद, नतीजे result_rag_a और result_rag_b ऑब्जेक्ट में सेव हो जाएंगे. हम अगले सेक्शन में इनका विश्लेषण करेंगे.

10. नतीजों का विश्लेषण करना

समीक्षा के नतीजे अब उपलब्ध हैं. result_rag_a और result_rag_b ऑब्जेक्ट में, हर लाइन के लिए कुल स्कोर और पूरी जानकारी होती है. इस टास्क में, आपको notebook_utils के हेल्पर फ़ंक्शन का इस्तेमाल करके इन नतीजों का विश्लेषण करना होगा.

एग्रीगेट की गई खास जानकारी देखना

  1. अहम जानकारी पाने के लिए, display_eval_result() हेल्पर फ़ंक्शन का इस्तेमाल करके, हर मेट्रिक के लिए औसत स्कोर देखें. मॉडल A की खास जानकारी देखने के लिए, नई सेल में यह कोड जोड़ें और चलाएं:
    notebook_utils.display_eval_result(
    title="Model A Eval Result", eval_result=result_rag_a
)
  2. मॉडल B के लिए भी ऐसा ही करें. इस कोड को नई सेल में जोड़ें और चलाएं:
    notebook_utils.display_eval_result(
    title="Model B Eval Result",
    eval_result=result_rag_b,
)

समीक्षा के नतीजों को विज़ुअलाइज़ करना

प्लॉट की मदद से, मॉडल की परफ़ॉर्मेंस की तुलना करना आसान हो जाता है. आपको दो तरह के विज़ुअलाइज़ेशन का इस्तेमाल करना होगा:

  • राडार प्लॉट: इससे हर मॉडल की परफ़ॉर्मेंस की पूरी "शेप" दिखती है. बड़ा आकार, बेहतर परफ़ॉर्मेंस दिखाता है.
  • बार प्लॉट: हर मेट्रिक की सीधी तुलना करने के लिए.

इन विज़ुअलाइज़ेशन से, आपको मॉडल की तुलना करने में मदद मिलेगी. जैसे, जवाब कितना काम का है, जवाब में भरोसेमंद स्रोतों से जानकारी ली गई है या नहीं, और जवाब कितना मददगार है.

  1. प्लॉटिंग के लिए, नतीजों को टपल की एक सूची में मिलाएं. हर टपल में मॉडल का नाम और उससे जुड़ा नतीजा ऑब्जेक्ट होना चाहिए. नई सेल में, यह कोड जोड़ें और चलाएं:
    eval_results = []
eval_results.append(("Model A", result_rag_a))
eval_results.append(("Model B", result_rag_b))
  2. अब, एक साथ सभी मेट्रिक के आधार पर मॉडल की तुलना करने के लिए, रडार प्लॉट जनरेट करें. नई सेल में यह कोड जोड़ें और चलाएं:
    notebook_utils.display_radar_plot(
    eval_results,
    metrics=[
    "question_answering_quality",
    "safety",
    "groundedness",
    "instruction_following",
    "relevance",
    "helpfulness",
    ],
)
    बड़ा आकार, बेहतर परफ़ॉर्मेंस दिखाता है.
  3. हर मेट्रिक की तुलना ज़्यादा सटीक तरीके से करने के लिए, बार प्लॉट जनरेट करें. नई सेल में, यह कोड जोड़ें और चलाएं:
    notebook_utils.display_bar_plot(
    eval_results,
    metrics=[
    "question_answering_quality",
    "safety",
    "groundedness",
    "instruction_following",
    "relevance",
    "helpfulness",
    ],
)
    इस विज़ुअलाइज़ेशन से, दोनों मॉडल के बीच परफ़ॉर्मेंस के अंतर को आसानी से देखा जा सकता है.

विज़ुअलाइज़ेशन से साफ़ तौर पर पता चलेगा कि मॉडल A की परफ़ॉर्मेंस, मॉडल B की तुलना में बेहतर है. रडार प्लॉट पर बड़ा आकार और बार चार्ट पर लंबी बार, मॉडल A की परफ़ॉर्मेंस को दिखाते हैं.

किसी इंस्टेंस के बारे में ज़्यादा जानकारी देखना

कुल स्कोर से, कुल परफ़ॉर्मेंस का पता चलता है. यह समझने के लिए कि किसी मॉडल ने कैसा परफ़ॉर्म किया, आपको हर उदाहरण के लिए, मूल्यांकन करने वाले एलएलएम से जनरेट किए गए जवाबों की समीक्षा करनी होगी.

  1. display_explanations() हेल्पर फ़ंक्शन की मदद से, अलग-अलग नतीजों की जांच की जा सकती है. मॉडल A के नतीजों में दिए गए दूसरे उदाहरण (num=2) के बारे में ज़्यादा जानकारी देखने के लिए, नई सेल में यह कोड जोड़ें और चलाएं:
    notebook_utils.display_explanations(result_rag_a, num=2)
  2. इस फ़ंक्शन का इस्तेमाल, सभी उदाहरणों में किसी खास मेट्रिक के लिए फ़िल्टर करने के लिए भी किया जा सकता है. इससे खराब परफ़ॉर्मेंस वाले किसी खास हिस्से को डीबग करने में मदद मिलती है. groundedness मेट्रिक पर मॉडल B का परफ़ॉर्मेंस स्कोर इतना खराब क्यों है, यह जानने के लिए इस कोड को नई सेल में जोड़ें और चलाएं:
    notebook_utils.display_explanations(result_rag_b, metrics=["groundedness"])
    इससे यह पता चलता है कि मॉडल कहां काम नहीं कर रहा है. यह जानकारी, मॉडल को बार-बार बेहतर बनाने के लिए ज़रूरी है.

11. "गोल्डन आंसर" का इस्तेमाल करके, जवाब का आकलन करना

इससे पहले, आपने बिना किसी रेफ़रंस के आकलन किया था. इसमें मॉडल के जवाब का आकलन सिर्फ़ प्रॉम्प्ट के आधार पर किया गया था. यह तरीका मददगार है, लेकिन इसमें असेस्मेंट व्यक्तिपरक होता है.

अब आपको रेफ़रंस किए गए इवैलुएशन का इस्तेमाल करना होगा. इस तरीके से, डेटासेट में "गोल्डन जवाब" (इसे रेफ़रंस जवाब भी कहा जाता है) जोड़ा जाता है. मॉडल के जवाब की तुलना, सही जवाब से करने पर परफ़ॉर्मेंस का ज़्यादा सटीक आकलन किया जा सकता है. इससे ये मेज़र किए जा सकते हैं:

  • तथ्यों का सही होना: क्या मॉडल का जवाब, गोल्डन आंसर में दिए गए तथ्यों के मुताबिक है?
  • मिलता-जुलता मतलब: क्या मॉडल के जवाब का मतलब, सही जवाब के मतलब से मिलता-जुलता है?
  • पूरी जानकारी होना: क्या मॉडल के जवाब में, गोल्डन जवाब की सभी मुख्य जानकारी शामिल है?

रेफ़र किए गए डेटासेट को तैयार करना

रेफ़रंस के आधार पर आकलन करने के लिए, आपको अपने डेटासेट में मौजूद हर उदाहरण के लिए "गोल्डन जवाब" जोड़ना होगा.

आइए, golden_answers सूची को तय करने से शुरुआत करें. मॉडल A के जवाबों की तुलना में, गोल्डन जवाबों से इस तरीके की वैल्यू का पता चलता है:

  • पहला सवाल (ब्रेन): जनरेट किया गया जवाब और सही जवाब एक जैसा है. मॉडल A सही है.
  • दूसरा सवाल (सीनेट): जवाबों का मतलब एक जैसा है, लेकिन उन्हें अलग-अलग शब्दों में लिखा गया है. एक अच्छी मेट्रिक को इसकी पहचान करनी चाहिए.
  • तीसरा सवाल (हसन-जलाली): कॉन्टेक्स्ट के हिसाब से, मॉडल A का जवाब तथ्यों के हिसाब से गलत है. golden_answer से इस गड़बड़ी का पता चलता है.
  1. नई सेल में, golden_answers की सूची तय करें
    golden_answers = [
    "frontal lobe and the parietal lobe",
    "Due to successes against Catiline.",
    "The Hasan-Jalalians commanded the area of Artsakh and Utik.",
]
  2. इस कोड को नीचे दी गई सेल में चलाकर, रेफ़र किए गए आकलन के डेटाफ़्रेम बनाएं:
    referenced_eval_dataset_rag_a = pd.DataFrame(
    {
        "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
        ],
        "response": generated_answers_by_rag_a,
        "reference": golden_answers,
    }
)

referenced_eval_dataset_rag_b = pd.DataFrame(
    {
        "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
        ],
        "response": generated_answers_by_rag_b,
        "reference": golden_answers,
    }
)
    यह कोड, golden_answers को उन मौजूदा वैरिएबल के साथ जोड़ता है जिन्हें आपने पहले बनाया था.

अब डेटासेट, रेफ़रंस के आधार पर आकलन करने के लिए तैयार हैं.

रेफ़र की गई कस्टम मेट्रिक बनाना

रेफ़र किए गए आकलन के लिए, कस्टम मेट्रिक भी बनाई जा सकती हैं. प्रोसेस पहले जैसी ही है. हालांकि, अब प्रॉम्प्ट टेंप्लेट में, सबसे सटीक जवाब के लिए {reference} प्लेसहोल्डर शामिल है.

"सही" जवाब के लिए, तथ्यों के सटीक होने का आकलन करने के लिए, बाइनरी स्कोरिंग (जैसे, सही के लिए 1 और गलत के लिए 0) का इस्तेमाल किया जा सकता है. आइए, इस लॉजिक को लागू करने वाली नई question_answering_correctness मेट्रिक बनाते हैं.

  1. प्रॉम्प्ट टेंप्लेट तय करें. नई सेल में, यह कोड जोड़ें और चलाएं:
    question_answering_correctness_prompt_template = """
You are a professional writing evaluator. Your job is to score writing responses according to pre-defined evaluation criteria.

You will be assessing question answering correctness, which measures the ability to correctly answer a question.

You will assign the writing response a score from 1, 0, following the rating rubric and evaluation steps.

### Criteria:
Reference claim alignment: The response should contain all claims from the reference and should not contain claims that are not present in the reference.

### Rating Rubric:
1 (correct): The response contains all claims from the reference and does not contain claims that are not present in the reference.
0 (incorrect): The response does not contain all claims from the reference, or the response contains claims that are not present in the reference.

### Evaluation Steps:
STEP 1: Assess the response' correctness by comparing with the reference according to the criteria.
STEP 2: Score based on the rubrics.

Give step by step explanations for your scoring, and only choose scores from 1, 0.


# User Inputs and AI-generated Response
## User Inputs
### Prompt
{prompt}

## Reference
{reference}

## AI-generated Response
{response}

"""
    इस टेंप्लेट में, आकलन करने वाले एलएलएम को मॉडल के {response} और गोल्डन {reference} जवाब के बीच सटीक तुलना करने का निर्देश दिया गया है. साथ ही, इसे सही (1) या गलत (0) के तौर पर स्कोर करने का निर्देश दिया गया है.
  2. प्रॉम्प्ट टेंप्लेट स्ट्रिंग को PointwiseMetric ऑब्जेक्ट में रैप करें. इससे आपकी मेट्रिक को एक औपचारिक नाम मिलता है. साथ ही, यह आकलन के काम के लिए फिर से इस्तेमाल किया जा सकने वाला कॉम्पोनेंट बन जाता है. नई सेल में यह कोड जोड़ें और चलाएं:
    question_answering_correctness = PointwiseMetric(
    metric="question_answering_correctness",
    metric_prompt_template=question_answering_correctness_prompt_template,
)

अब आपके पास तथ्यों की बारीकी से जांच करने के लिए, कस्टम मेट्रिक है.

12. संदर्भित जवाब की जांच करना

अब, रेफ़र किए गए डेटासेट और नई मेट्रिक की मदद से, आकलन के काम को कॉन्फ़िगर करें. आपको EvalTask क्लास का फिर से इस्तेमाल करना होगा.

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

  • exact_match: जनरेट किए गए जवाब के रेफ़रंस जवाब से पूरी तरह मेल खाने पर ही 1 स्कोर मिलता है. ऐसा न होने पर 0 स्कोर मिलता है.
  • bleu: यह सटीक होने की मेट्रिक है. इससे यह पता चलता है कि जनरेट किए गए जवाब में मौजूद कितने शब्द, रेफ़रंस जवाब में भी मौजूद हैं.
  • rouge: यह रिकॉल की मेट्रिक है. इससे यह पता चलता है कि जनरेट किए गए जवाब में, रेफ़रंस जवाब के कितने शब्द शामिल हैं.
  1. रेफ़र किए गए डेटासेट और मेट्रिक के नए मिक्स के साथ, आकलन के लिए जॉब कॉन्फ़िगर करें. EvalTask ऑब्जेक्ट बनाने के लिए, नई सेल में यह कोड जोड़ें और चलाएं:
    referenced_answer_eval_task_rag_a = EvalTask(
    dataset=referenced_eval_dataset_rag_a,
    metrics=[
    question_answering_correctness,
    "rouge",
    "bleu",
    "exact_match",
    ],
    experiment=EXPERIMENT,
)

referenced_answer_eval_task_rag_b = EvalTask(
    dataset=referenced_eval_dataset_rag_b,
    metrics=[
    question_answering_correctness,
    "rouge",
    "bleu",
    "exact_match",
    ],
    experiment=EXPERIMENT,
)
  2. .evaluate() तरीके को कॉल करके, रेफ़रंस किए गए आकलन को लागू करें. इस कोड को नई सेल में जोड़ें और चलाएं:
    referenced_result_rag_a = referenced_answer_eval_task_rag_a.evaluate()
referenced_result_rag_b = referenced_answer_eval_task_rag_b.evaluate()

13. रेफ़र किए गए नतीजों का विश्लेषण करना

समीक्षा की जा चुकी है. इस टास्क में, आपको नतीजों का विश्लेषण करना होगा. इसके लिए, आपको मॉडल के जवाबों की तुलना, गोल्डन रेफ़रंस जवाबों से करनी होगी. इससे, मॉडल के जवाबों में मौजूद तथ्यों की सटीकता का आकलन किया जा सकेगा.

खास जानकारी वाले नतीजे देखना

  • रेफ़र किए गए आकलन के लिए, खास जानकारी वाले नतीजों का विश्लेषण करें. नई सेल में, दोनों मॉडल के लिए खास जानकारी वाली टेबल दिखाने के लिए, यह कोड जोड़ें और चलाएं:
    notebook_utils.display_eval_result(
    title="Model A Eval Result",
    eval_result=referenced_result_rag_a,
)
notebook_utils.display_eval_result(
    title="Model B Eval Result",
    eval_result=referenced_result_rag_b,
)
    आपको दिखेगा कि मॉडल A, आपकी कस्टम question_answering_correctness मेट्रिक पर अच्छा परफ़ॉर्म करता है, लेकिन exact_match पर उसका स्कोर कम है. इससे मॉडल पर आधारित मेट्रिक की वैल्यू का पता चलता है. ये मेट्रिक, सिर्फ़ एक जैसे टेक्स्ट की नहीं, बल्कि सिमैंटिक समानता की भी पहचान कर सकती हैं.

तुलना करने के लिए नतीजों को विज़ुअलाइज़ करना

विज़ुअलाइज़ेशन से, दोनों मॉडल के बीच परफ़ॉर्मेंस का अंतर ज़्यादा साफ़ तौर पर दिखता है. सबसे पहले, नतीजों को एक सूची में मिलाएं, ताकि उन्हें प्लॉट किया जा सके. इसके बाद, रडार और बार प्लॉट जनरेट करें.

  1. प्लॉटिंग के लिए, रेफ़र किए गए इवैलुएशन के नतीजों को एक सूची में मिलाएं. नई सेल में यह कोड जोड़ें और चलाएं:
    referenced_eval_results = []
referenced_eval_results.append(("Model A", referenced_result_rag_a))
referenced_eval_results.append(("Model B", referenced_result_rag_b))
  2. मेट्रिक के नए सेट के हिसाब से, हर मॉडल की परफ़ॉर्मेंस को विज़ुअलाइज़ करने के लिए, रडार प्लॉट जनरेट करें. इस कोड को नई सेल में जोड़ें और चलाएं:
    notebook_utils.display_radar_plot(
    referenced_eval_results,
    metrics=[
        "question_answering_correctness",
        "rouge",
        "bleu",
        "exact_match",
    ],
)
  3. एक साथ तुलना करने के लिए, बार प्लॉट बनाएं. इससे पता चलेगा कि अलग-अलग मेट्रिक पर हर मॉडल ने कैसा परफ़ॉर्म किया. नई सेल में यह कोड जोड़ें और चलाएं:
    notebook_utils.display_bar_plot(
    referenced_eval_results,
    metrics=[
        "question_answering_correctness",
        "rouge",
        "bleu",
        "exact_match",
    ],
)

इन विज़ुअलाइज़ेशन से पता चलता है कि मॉडल A, मॉडल B की तुलना में ज़्यादा सटीक है और इसमें रेफ़रंस जवाबों के हिसाब से तथ्य शामिल हैं.

14. प्रैक्टिस से लेकर प्रोडक्शन तक

आपने RAG सिस्टम के लिए, पूरी तरह से काम करने वाली इवैल्यूएशन पाइपलाइन को लागू कर दिया है. इस आखिरी सेक्शन में, उन मुख्य रणनीतिक सिद्धांतों के बारे में खास जानकारी दी गई है जिनके बारे में आपने सीखा है. साथ ही, इन कौशल को असल दुनिया के प्रोजेक्ट में लागू करने के लिए एक फ़्रेमवर्क दिया गया है.

प्रोडक्शन के सबसे सही तरीके

इस लैब में सीखी गई बातों को असल दुनिया के प्रोडक्शन एनवायरमेंट में लागू करने के लिए, इन चार मुख्य तरीकों को अपनाएं:

  • सीआई/सीडी की मदद से ऑटोमेट करें: अपनी जांच की सुविधा को सीआई/सीडी पाइपलाइन (जैसे, Cloud Build, GitHub Actions) में इंटिग्रेट करें. कोड में हुए बदलावों का आकलन अपने-आप होता है. इससे रिग्रेशन का पता चलता है. साथ ही, क्वालिटी स्कोर आपके तय किए गए स्टैंडर्ड से कम होने पर, डिप्लॉयमेंट को ब्लॉक किया जा सकता है.
  • अपने डेटासेट को बेहतर बनाएं: स्टैटिक डेटासेट पुराना हो जाता है. Git LFS या Cloud Storage का इस्तेमाल करके, अपने "गोल्डन" टेस्ट सेट को वर्शन कंट्रोल करें. साथ ही, असली (पहचान छिपाकर) उपयोगकर्ता की क्वेरी से सैंपल लेकर, लगातार नए और मुश्किल उदाहरण जोड़ें.
  • सिर्फ़ जनरेटर ही नहीं, बल्कि रिट्रीवर का भी आकलन करें: सही कॉन्टेक्स्ट के बिना, अच्छा जवाब नहीं दिया जा सकता. अपने जवाब पाने की सुविधा वाले सिस्टम के लिए, आकलन का एक अलग चरण लागू करें. इसके लिए, हिट रेट (क्या सही दस्तावेज़ मिला?) और औसत पारस्परिक रैंक (एमआरआर) (सही दस्तावेज़ को कितनी ऊंची रैंक मिली?) जैसी मेट्रिक का इस्तेमाल करें.
  • समय के साथ मेट्रिक पर नज़र रखें: अपने आकलन के रन से, खास जानकारी वाले स्कोर को Google Cloud Monitoring जैसी सेवा में एक्सपोर्ट करें. क्वालिटी के रुझानों को ट्रैक करने के लिए डैशबोर्ड बनाएं. साथ ही, परफ़ॉर्मेंस में होने वाली बड़ी गिरावट के बारे में सूचना पाने के लिए, अपने-आप मिलने वाली सूचनाएं सेट अप करें.

आकलन के ऐडवांस तरीके की मैट्रिक्स

आकलन का सही तरीका चुनना, आपके लक्ष्यों पर निर्भर करता है. इस मैट्रिक्स में बताया गया है कि हर तरीके का इस्तेमाल कब करना चाहिए.

आकलन का तरीका

इस्तेमाल के सबसे सही उदाहरण

मुख्य फ़ायदे

सीमाएं

रेफ़रंस के बिना

प्रोडक्शन की निगरानी करना, लगातार आकलन करना

इसमें सबसे सही जवाब देने की ज़रूरत नहीं होती. इसमें सिर्फ़ यह देखा जाता है कि जवाब कितना अच्छा है

ज़्यादा महंगा, संभावित मूल्यांकक पूर्वाग्रह

रेफ़रंस पर आधारित

मॉडल की तुलना, बेंचमार्किंग

ऑब्जेक्टिव मेज़रमेंट, तेज़ी से कंप्यूटेशन

इसमें सटीक जवाबों की ज़रूरत होती है. हालांकि, इसमें शब्दों के मतलब के एक जैसे होने की जानकारी नहीं मिल सकती

कस्टम मेट्रिक

डोमेन के हिसाब से आकलन

कारोबार की ज़रूरतों के हिसाब से तैयार किया गया है

पुष्टि करने और डेवलपमेंट में ज़्यादा समय लगता है

हाइब्रिड अप्रोच

कॉम्प्रिहेंसिव प्रोडक्शन सिस्टम

सभी तरीकों में सबसे अच्छा

ज़्यादा मुश्किल, लागत को ऑप्टिमाइज़ करने की ज़रूरत है

तकनीकी जानकारी

अपने RAG सिस्टम बनाते और उनका आकलन करते समय, इन मुख्य सिद्धांतों को ध्यान में रखें:

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

प्रोडक्शन डिप्लॉयमेंट के फ़ैसले से जुड़ा फ़्रेमवर्क

इस फ़ेज़ वाले फ़्रेमवर्क का इस्तेमाल, आने वाले समय में RAG सिस्टम को डिप्लॉय करने के लिए एक गाइड के तौर पर करें:

  • पहला चरण - डेवलपमेंट: मॉडल की तुलना करने और उसे चुनने के लिए, जाने-पहचाने टेस्ट सेट के साथ रेफ़रंस-आधारित आकलन का इस्तेमाल करें.
  • दूसरा चरण - प्री-प्रोडक्शन: ऐप्लिकेशन या गेम, प्रोडक्शन के लिए तैयार है या नहीं, इसकी पुष्टि करने के लिए, दोनों तरीकों को मिलाकर पूरी तरह से आकलन करें.
  • तीसरा चरण - प्रोडक्शन: बिना किसी रेफ़रंस के मॉनिटरिंग की सुविधा लागू करें, ताकि गोल्डन जवाबों के बिना क्वालिटी का लगातार आकलन किया जा सके.
  • चौथा चरण - ऑप्टिमाइज़ेशन: मॉडल को बेहतर बनाने और जानकारी वापस पाने की सिस्टम को बेहतर बनाने के लिए, आकलन से मिली अहम जानकारी का इस्तेमाल करें.

15. नतीजा

बधाई हो! आपने लैब पूरी कर ली है.

यह लैब, Google Cloud के साथ प्रोडक्शन-रेडी एआई के लर्निंग पाथ का हिस्सा है.

  • प्रोटोटाइप से प्रोडक्शन तक के अंतर को कम करने के लिए, पूरा पाठ्यक्रम देखें.
  • अपनी प्रोग्रेस को ProductionReadyAI हैशटैग के साथ शेयर करें.

रीकैप

आपने यह सीखा है कि:

  • जवाब की क्वालिटी का आकलन करने के लिए, बिना किसी रेफ़रंस के जवाब का आकलन करें. यह आकलन, खोजे गए कॉन्टेक्स्ट के आधार पर किया जाता है.
  • जवाब में मौजूद तथ्यों के सही होने का आकलन करने के लिए, "गोल्डन आंसर" जोड़कर, जवाब का आकलन करें.
  • दोनों तरीकों के लिए, पहले से तय और कस्टम मेट्रिक का इस्तेमाल करें.
  • मॉडल पर आधारित मेट्रिक (जैसे कि question_answering_quality) और कैलकुलेशन पर आधारित मेट्रिक (rouge, bleu, exact_match) दोनों का इस्तेमाल करें.
  • मॉडल की खूबियों और कमियों को समझने के लिए, नतीजों का विश्लेषण करें और उन्हें विज़ुअलाइज़ करें.

आकलन के इस तरीके से, आपको ज़्यादा भरोसेमंद और सटीक जनरेटिव एआई ऐप्लिकेशन बनाने में मदद मिलती है.