आकलन

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

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

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

import { GenkitMetric, genkitEval } from '@genkit-ai/evaluator';
import { textEmbeddingGecko } from '@genkit-ai/vertexai';

export default configureGenkit({
  plugins: [
    genkitEval({
      judge: geminiPro,
      metrics: [GenkitMetric.FAITHFULNESS, GenkitMetric.ANSWER_RELEVANCY],
      embedder: textEmbeddingGecko, // GenkitMetric.ANSWER_RELEVANCY requires an embedder
    }),
  ],
  // ...
});

  npm install @genkit-ai/evaluator @genkit-ai/vertexai

इनपुट का वह सेट तय करके शुरुआत करें जिसका इस्तेमाल आपको testQuestions.json नाम के इनपुट डेटासेट के तौर पर करना है. यह इनपुट डेटासेट, टेस्ट केस दिखाता है. इनका इस्तेमाल करके, इवैलुएशन के लिए आउटपुट जनरेट किया जाएगा.

[
  "What is on the menu?",
  "Does the restaurant have clams?",
  "What is the special of the day?"
]

इसके बाद, eval:flow कमांड का इस्तेमाल करके, testQuestions.json में दिए गए टेस्ट केस के हिसाब से अपने फ़्लो का आकलन किया जा सकता है.

genkit eval:flow menuQA --input testQuestions.json

इसके बाद, डेवलपर यूज़र इंटरफ़ेस (यूआई) में इवैलुएशन के नतीजे देखे जा सकते हैं. इसके लिए यह कमांड दें:

genkit start

इसके बाद, localhost:4000/evaluate पर जाएं.

इसके अलावा, किसी json फ़ाइल में आउटपुट की जांच करने के लिए, कोई आउटपुट फ़ाइल दी जा सकती है.

genkit eval:flow menuQA --input testQuestions.json --output eval-result.json

इन समीक्षकों की मदद ली जा सकती है

जेनकिट के समीक्षक

Genkit में कुछ स्थानीय समीक्षक शामिल हैं, जो RAGAS से प्रेरित हैं. इनसे आपको शुरुआत करने में मदद मिलेगी:

• विश्वास
• जवाब कितने काम का है
• नुकसान

मूल्यांकन करने वाले प्लगिन

जेनकिट, प्लगिन की मदद से अन्य समीक्षकों की मदद करता है:

• VertexAI प्लगिन के ज़रिए VertexAI Rapid Evaluators.
• LangChain प्लगिन की मदद से LangChain Criteria evaluation.

बेहतर इस्तेमाल के लिए

फ़्लो का तुरंत आकलन करने के लिए, eval:flow एक आसान तरीका है. हालांकि, कभी-कभी आपको आकलन के चरणों पर ज़्यादा कंट्रोल की ज़रूरत पड़ सकती है. ऐसा तब हो सकता है, जब कोई दूसरा फ़्रेमवर्क इस्तेमाल किया जा रहा हो और आपके पास पहले से ही कुछ ऐसे आउटपुट हों जिनका आपको आकलन करना है. eval:flow वह चरण पूरा कर सकता है जिसे पूरी तरह मैन्युअल तरीके से पूरा किया जाता है.

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

अपने टेस्ट इनपुट के ऊपर फ़्लो चलाएं:

genkit flow:batchRun myRagFlow test_inputs.json --output flow_outputs.json --label customLabel

इवैलुएशन डेटा एक्सट्रैक्ट करें:

genkit eval:extractData myRagFlow --label customLabel --output customLabel_dataset.json

एक्सपोर्ट किया गया डेटा, json फ़ाइल के तौर पर दिखाया जाएगा. इसमें हर testCase इस फ़ॉर्मैट में होगा:

[
  {
    "testCaseId": string,
    "input": string,
    "output": string,
    "context": array of strings,
    "traceIds": array of strings,
  }
]

डेटा इकट्ठा करने वाला टूल, रिट्रीवर का अपने-आप पता लगाएगा और बनाए गए दस्तावेज़ों को कॉन्टेक्स्ट कलेक्शन में जोड़ देगा. डिफ़ॉल्ट रूप से, कॉन्फ़िगर किए गए सभी समीक्षकों के लिए eval:run चलेगा. साथ ही, eval:flow की तरह ही, eval:run के नतीजे भी डेवलपर यूज़र इंटरफ़ेस (यूआई) के आकलन वाले पेज पर दिखेंगे. यह पेज localhost:4000/evaluate पर मौजूद है.

पसंद के मुताबिक डेटा इकट्ठा करने वाले टूल

आपके पास eval:extractData और eval:flow कमांड में इस्तेमाल करने के लिए, कस्टम डेटा इकट्ठा करने वाले टूल उपलब्ध कराने का विकल्प भी है. कस्टम डेटा इकट्ठा करने वाले टूल की मदद से, डेटा एक्सट्रैक्ट करने के डिफ़ॉल्ट लॉजिक को बदला जा सकता है. इससे डेटासेट बनाने और उनका आकलन करने में मदद मिलती है.

अगर आपके पास पहले से कोई टूल कॉन्फ़िगरेशन फ़ाइल नहीं है, तो कस्टम एक्सट्रैक्टर कॉन्फ़िगर करने के लिए, अपने प्रोजेक्ट रूट में genkit-tools.conf.js नाम की टूल कॉन्फ़िगरेशन फ़ाइल जोड़ें.

cd $GENKIT_PROJECT_HOME
touch genkit-tools.conf.js

टूल कॉन्फ़िगरेशन फ़ाइल में, यह कोड जोड़ें:

module.exports = {
  evaluators: [
    {
      flowName: 'myFlow',
      extractors: {
        context: { outputOf: 'foo-step' },
        output: 'bar-step',
      },
    },
  ],
};

इस सैंपल में, myFlow फ़्लो के लिए एक्सट्रैक्टर कॉन्फ़िगर किया गया है. कॉन्फ़िगरेशन, context और output फ़ील्ड के लिए एक्सट्रैक्टर को बदल देता है और input फ़ील्ड के लिए डिफ़ॉल्ट लॉजिक का इस्तेमाल करता है.

इवैलुएशन डेटा इकट्ठा करने वाले टूल की खास जानकारी यहां दी गई है:

• evaluators फ़ील्ड, EvaluatorConfig ऑब्जेक्ट की कैटगरी को स्वीकार करता है, जिसका दायरा flowName के दायरे में आता है
• extractors एक ऑब्जेक्ट है, जो डेटा इकट्ठा करने वाले टूल के बदलावों के बारे में बताता है. extractors में फ़िलहाल इस्तेमाल की जा सकने वाली कुंजियां [input, output, context] हैं. इन टाइप की वैल्यू स्वीकार की जाती हैं:
  • string - यह कदम का नाम होना चाहिए, जिसे स्टिरिंग के तौर पर सेट किया गया हो. इस कुंजी के लिए, इस चरण का आउटपुट निकाला जाता है.
  • { inputOf: string } या { outputOf: string } - ये ऑब्जेक्ट किसी चरण के खास चैनल (इनपुट या आउटपुट) दिखाते हैं. उदाहरण के लिए, { inputOf: 'foo-step' } इस कुंजी के लिए, foo-step चरण का इनपुट एक्सट्रैक्ट करेगा.
  • (trace) => string; - बेहतर तरीके से काम करने के लिए, ऐसा फ़ंक्शन दिया जा सकता है जो Genkit ट्रेस को स्वीकार करता हो और string दिखाता हो. साथ ही, इस फ़ंक्शन में एक्सट्रैक्शन लॉजिक के बारे में भी बताएं. सटीक TraceData स्कीमा के लिए, genkit/genkit-tools/common/src/types/trace.ts देखें.

मौजूदा डेटासेट पर चल रहा है

पहले से निकाले गए डेटासेट का आकलन करने के लिए:

genkit eval:run customLabel_dataset.json

किसी दूसरी जगह पर आउटपुट करने के लिए, --output फ़्लैग का इस्तेमाल करें.

genkit eval:flow menuQA --input testQuestions.json --output customLabel_evalresult.json

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

genkit eval:run customLabel_dataset.json --evaluators=genkit/faithfulness,genkit/answer_relevancy

एलएलएम का इस्तेमाल करके, टेस्ट डेटा को सिंथेसाइज़ करना

यहां PDF फ़ाइल का इस्तेमाल करने का एक उदाहरण दिया गया है. इसमें, ऐसे संभावित सवाल जनरेट किए जा सकते हैं जो उपयोगकर्ता आपसे पूछ सकते हैं.

export const synthesizeQuestions = defineFlow(
  {
    name: 'synthesizeQuestions',
    inputSchema: z.string().describe('PDF file path'),
    outputSchema: z.array(z.string()),
  },
  async (filePath) => {
    filePath = path.resolve(filePath);
    const pdfTxt = await run('extract-text', () => extractText(filePath));

    const chunks = await run('chunk-it', async () =>
      chunk(pdfTxt, chunkingConfig)
    );

    const questions: string[] = [];
    for (var i = 0; i < chunks.length; i++) {
      const qResponse = await generate({
        model: geminiPro,
        prompt: {
          text: `Generate one question about the text below: ${chunks[i]}`,
        },
      });
      questions.push(qResponse.text());
    }
    return questions;
  }
);

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

genkit flow:run synthesizeQuestions '"my_input.pdf"' --output synthesizedQuestions.json