इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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

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

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

रेफ़रंस

कोड सैंपल: यह लैब, Vertex AI के आकलन से जुड़े दस्तावेज़ में दिए गए उदाहरणों पर आधारित है
डेटासेट फ़ाउंडेशन: SQuAD 2.0 Question Answering Dataset
RAG से जानकारी पाने की प्रोसेस को ऑप्टिमाइज़ करना: टेस्ट करें, ट्यून करें, और सफल हों

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

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

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

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

Google खाता

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

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

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

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

Google Cloud के 500 रुपये के क्रेडिट रिडीम करें (ज़रूरी नहीं)

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

इस लिंक पर क्लिक करें और किसी निजी Google खाते से साइन इन करें. आपको इस तरह की विंडो दिखेगी:
अपने क्रेडिट ऐक्सेस करने के लिए यहां क्लिक करें बटन पर क्लिक करें. इससे आपको एक ऐसे पेज पर ले जाया जाएगा जहां आपको अपनी बिलिंग प्रोफ़ाइल सेट अप करनी होगी
पुष्टि करें पर क्लिक करें. अब आप Google Cloud Platform के ट्रायल बिलिंग खाते से कनेक्ट हो गए हैं.

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

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

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

ध्यान दें:

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

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

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

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

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

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

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

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

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

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

मल्टी-कॉम्पोनेंट चैलेंज: RAG सिस्टम में तीन ऑपरेशन शामिल होते हैं. इनमें से कोई भी ऑपरेशन फ़ेल हो सकता है:

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

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

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

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

Cloud Console के एपीआई और सेवाएं पेज पर जाएं.
Vertex AI API के लिए, चालू करें पर क्लिक करें.

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

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

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

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

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

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

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

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

आकलन के काम के लिए, कॉन्फ़िगरेशन वैरिएबल तय करें. नई सेल में, इस रन को व्यवस्थित करने के लिए, 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")
```
Vertex AI SDK टूल को शुरू करें. नई सेल में, यह कोड जोड़ें और चलाएं.
```
vertexai.init(project=PROJECT_ID, location=LOCATION)
```
इस चरण में, आपकी नोटबुक की पुष्टि की जाती है और उसे आपके Google Cloud प्रोजेक्ट से कनेक्ट किया जाता है.
अगली सेल में यह कोड चलाकर, ज़रूरी क्लास को मूल्यांकन SDK से इंपोर्ट करें:
```
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) से मिले कॉन्टेक्स्ट के साथ जोड़ना होगा. यह इसलिए ज़रूरी है, ताकि आकलन करने वाली सेवा को पता चल सके कि मॉडल ने जवाब बनाने के लिए किस जानकारी का इस्तेमाल किया है.
जवाब: यह आपके RAG मॉडल का फ़ाइनल जवाब है.

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

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

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

नई सेल में, सवालों और जनरेट किए गए जवाबों के दो सेट को तय करने के लिए, यह कोड जोड़ें और चलाएं.
```
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.",
]
```
इससे आपके डेटासेट के मुख्य कॉम्पोनेंट तय होते हैं: सवाल, हर सवाल के लिए RAG सिस्टम से हासिल किए गए कॉन्टेक्स्ट के लंबे पैसेज, और दो अलग-अलग मॉडल (बेहतर परफ़ॉर्म करने वाला मॉडल A और खराब परफ़ॉर्म करने वाला मॉडल B) से जनरेट किए गए जवाब.

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.",
]

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

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,
    }
)

मॉडल A के डेटासेट की शुरुआती कुछ पंक्तियां देखने के लिए, नई सेल में यह कोड चलाएं.
```
eval_dataset_rag_a
```
यह पक्का करने के लिए कि इसे सही तरीके से बनाया गया है, यह तरीका अपनाना अच्छा होता है.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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}
"""

इसी तरीके का इस्तेमाल करके, 'काम का जवाब' मेट्रिक के लिए प्रॉम्प्ट टेंप्लेट तय करें. नई सेल में यह कोड जोड़ें और चलाएं:

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}
"""

अपनी दो कस्टम मेट्रिक के लिए 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 एक्सपेरिमेंट है, जिसमें नतीजों को लॉग किया जाता है. इससे आपको रन को ट्रैक करने और उनकी तुलना करने में मदद मिलती है.

हर मॉडल के लिए एक 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 ऑब्जेक्ट.
टास्क कॉन्फ़िगर करने के बाद, .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 के हेल्पर फ़ंक्शन का इस्तेमाल करके इन नतीजों का विश्लेषण करना होगा.

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

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

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

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

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

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

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

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

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

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

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

11. "गोल्डन आंसर" का इस्तेमाल करके, रेफ़रंस के आधार पर आकलन करना

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

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

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

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

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

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

पहला सवाल (दिमाग): जनरेट किया गया जवाब और सही जवाब एक जैसा है. मॉडल A सही है.
दूसरा सवाल (सीनेट): जवाबों का मतलब एक जैसा है, लेकिन उन्हें अलग-अलग शब्दों में लिखा गया है. एक अच्छी मेट्रिक को इसकी पहचान करनी चाहिए.
तीसरा सवाल (हसन-जलाली): मॉडल A का जवाब, कॉन्टेक्स्ट के हिसाब से तथ्यों के आधार पर गलत है. golden_answer इस गड़बड़ी को दिखाता है.

नई सेल में, 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.",
]

इस कोड को नीचे दी गई सेल में चलाकर, रेफ़र किए गए आकलन के डेटाफ़्रेम बनाएं:

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 मेट्रिक बनाते हैं.

प्रॉम्प्ट टेंप्लेट तय करें. नई सेल में, यह कोड जोड़ें और चलाएं:

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).

प्रॉम्प्ट टेंप्लेट स्ट्रिंग को 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: यह रिकॉल की मेट्रिक है. इससे यह पता चलता है कि जनरेट किए गए जवाब में, रेफ़रंस जवाब के कितने शब्द शामिल हैं.

रेफ़र किए गए डेटासेट और मेट्रिक के नए मिक्स के साथ, समीक्षा करने वाली जॉब को कॉन्फ़िगर करें. 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,
)

.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 पर उसका स्कोर कम है. इससे मॉडल पर आधारित मेट्रिक की वैल्यू का पता चलता है. ये मेट्रिक, सिर्फ़ एक जैसे टेक्स्ट की पहचान नहीं कर सकतीं, बल्कि सिमैंटिक समानता की भी पहचान कर सकती हैं.

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

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

प्लॉटिंग के लिए, रेफ़र किए गए इवैलुएशन के नतीजों को एक सूची में मिलाएं. नई सेल में यह कोड जोड़ें और चलाएं:
```
referenced_eval_results = []
referenced_eval_results.append(("Model A", referenced_result_rag_a))
referenced_eval_results.append(("Model B", referenced_result_rag_b))
```
मेट्रिक के नए सेट के हिसाब से, हर मॉडल की परफ़ॉर्मेंस को विज़ुअलाइज़ करने के लिए, रडार प्लॉट जनरेट करें. इस कोड को नई सेल में जोड़ें और चलाएं:
```
notebook_utils.display_radar_plot(
    referenced_eval_results,
    metrics=[
        "question_answering_correctness",
        "rouge",
        "bleu",
        "exact_match",
    ],
)
```
सीधे तौर पर एक साथ तुलना करने के लिए, बार प्लैट बनाएं. इससे पता चलेगा कि अलग-अलग मेट्रिक पर हर मॉडल ने कैसा परफ़ॉर्म किया. नई सेल में यह कोड जोड़ें और चलाएं:
```
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) दोनों का इस्तेमाल करें.
मॉडल की खूबियों और कमियों को समझने के लिए, नतीजों का विश्लेषण करें और उन्हें विज़ुअलाइज़ करें.

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