आकलन

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

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

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

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

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

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

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

["Cheese", "Broccoli", "Spinach and Kale"]

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

genkit eval:flow menuSuggestionFlow --input testInputs.json

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

genkit start

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

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

genkit eval:flow menuSuggestionFlow --input testInputs.json --output eval-result.json

काम करने वाले समीक्षक

Genkit के समीक्षक

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

  • ईमानदारी
  • जवाब कितने काम का है
  • नुकसान पहुंचाने वाला कॉन्टेंट

इवैलुएटर प्लगिन

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

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

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

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

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

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 menuSuggestionFlow --input testInputs.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: gemini15Flash,
        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