आकलन

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

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

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

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

const ai = genkit({
  plugins: [
    vertexAI(),
    genkitEval({
      judge: gemini15Flash,
      metrics: [GenkitMetric.FAITHFULNESS, GenkitMetric.ANSWER_RELEVANCY],
      embedder: textEmbedding004, // GenkitMetric.ANSWER_RELEVANCY requires an embedder
    }),
  ],
  // ...
});

ध्यान दें: ऊपर दिए गए कॉन्फ़िगरेशन के लिए, genkit, @genkit-ai/google-ai, @genkit-ai/evaluator, और @genkit-ai/vertexai पैकेज इंस्टॉल करने होंगे.

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

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

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

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

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, VertexAI प्लग इन की मदद से, VertexAI रैपिड एवल्यूएटर जैसे प्लग इन के ज़रिए, अन्य एवल्यूएटर के साथ काम करता है.

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

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: [
    {
      actionRef: '/flow/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 देखें.

ध्यान दें: इन सभी चरणों के लिए, निकाला गया डेटा एक JSON स्ट्रिंग होगी. आकलन के समय, टूल इस JSON स्ट्रिंग को अपने-आप पार्स कर देगा. अगर फ़ंक्शन एक्सट्रैक्टर दिया जा रहा है, तो पक्का करें कि आउटपुट मान्य JSON स्ट्रिंग हो. उदाहरण के लिए: "Hello, world!" मान्य JSON नहीं है; "\"Hello, world!\"" मान्य है.

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

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

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 फ़ाइल का इस्तेमाल करके, ऐसे संभावित सवाल जनरेट किए गए हैं जो उपयोगकर्ता उससे पूछ सकते हैं.

import { genkit, run, z } from "genkit";
import { googleAI, gemini15Flash } from "@genkit-ai/googleai";
import { chunk } from "llm-chunk";

const ai = genkit({ plugins: [googleAI()] });

export const synthesizeQuestions = ai.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 ai.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