आकलन

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

Firebase Genkit, प्लग इन की मदद से तीसरे पक्ष के आकलन टूल के साथ काम करता है. साथ ही, इसमें बेहतरीन निगरानी की सुविधाएं भी होती हैं. इन सुविधाओं से, LLM की मदद से काम करने वाले ऐप्लिकेशन की रनटाइम स्थिति के बारे में अहम जानकारी मिलती है. 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/googleai, @genkit-ai/evaluator, और @genkit-ai/vertexai पैकेज इंस्टॉल करने होंगे.

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

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

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

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

{
  "samples": [
    {
      "input": "What is the French word for Cheese?",
      "reference": "Fromage"
    },
    {
      "input": "What green vegetable looks like cauliflower?",
      "reference": "Broccoli"
    }
  ]
}

ध्यान दें कि इनपुट JSON फ़ाइल में, किसी भी तरह के JSON डेटा टाइप का इस्तेमाल किया जा सकता है. Genkit, उन्हें उसी डेटा टाइप के साथ आपके फ़्लो में भेज देगा.

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

genkit eval:flow menuSuggestionFlow --input testInputs.json

अगर आपके फ़्लो को पुष्टि की ज़रूरत है, तो --auth आर्ग्युमेंट का इस्तेमाल करके इसकी जानकारी दी जा सकती है:

genkit eval:flow menuSuggestionFlow --input testInputs.json --auth "{\"email_verified\": true}"

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

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";
import path from 'path';

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

const chunkingConfig = {
  minLength: 1000, // number of minimum characters into chunk
  maxLength: 2000, // number of maximum characters into chunk
  splitter: 'sentence', // paragraph | sentence
  overlap: 100, // number of overlap chracters
  delimiters: '', // regex for base split method
} as any;

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);
    // `extractText` loads the PDF and extracts its contents as text.
    // See our RAG documentation for more details. 
    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