การประเมิน

การประเมินเป็นการทดสอบรูปแบบหนึ่งที่จะช่วยคุณตรวจสอบคำตอบของ LLM และตรวจสอบว่าคำตอบเหล่านั้นเป็นไปตามมาตรฐานคุณภาพของคุณ

Firebase Genkit รองรับเครื่องมือประเมินของบุคคลที่สามผ่านปลั๊กอิน ซึ่งทำงานร่วมกับฟีเจอร์การสังเกตการณ์ที่มีประสิทธิภาพซึ่งให้ข้อมูลเชิงลึกเกี่ยวกับสถานะรันไทม์ของแอปพลิเคชันที่ทำงานด้วย LLM เครื่องมือ Genkit ช่วยให้คุณดึงข้อมูลโดยอัตโนมัติ ซึ่งรวมถึงอินพุต เอาต์พุต และข้อมูลจากขั้นตอนกลางเพื่อประเมินคุณภาพของคำตอบ LLM ตั้งแต่ต้นจนจบ รวมถึงทำความเข้าใจประสิทธิภาพขององค์ประกอบพื้นฐานของระบบ

ตัวอย่างเช่น หากคุณมีเวิร์กโฟลว์ RAG ทาง Genkit จะดึงชุดเอกสารที่เครื่องมือดึงข้อมูลแสดงผลเพื่อให้คุณประเมินคุณภาพของเครื่องมือดึงข้อมูลขณะที่ทำงานในบริบทของเวิร์กโฟลว์ดังที่แสดงด้านล่างด้วยเมตริกความถูกต้องของ 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}"

จากนั้นคุณจะเห็นผลการประเมินใน UI ของนักพัฒนาซอฟต์แวร์โดยเรียกใช้คำสั่งต่อไปนี้

genkit start

จากนั้นไปที่ localhost:4000/evaluate

หรือจะระบุไฟล์เอาต์พุตเพื่อตรวจสอบเอาต์พุตในไฟล์ JSON ก็ได้

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

หมายเหตุ: ด้านล่างนี้คือตัวอย่างวิธีที่ LLM ช่วยสร้างกรณีทดสอบ

ผู้ประเมินที่รองรับ

ผู้ประเมิน 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:run จะปรากฏในหน้าการประเมินของ UI สําหรับนักพัฒนาซอฟต์แวร์ ซึ่งอยู่ที่ localhost:4000/evaluate เช่นเดียวกับ eval:flow

เครื่องมือแยกข้อมูลที่กำหนดเอง

นอกจากนี้ คุณยังระบุเครื่องมือแยกข้อมูลที่กําหนดเองเพื่อใช้ในคําสั่ง 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

หากต้องการส่งออกไปยังตำแหน่งอื่น ให้ใช้ Flag --output

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

หากต้องการเรียกใช้กับชุดย่อยของเครื่องมือประเมินที่กําหนดค่าไว้ ให้ใช้ Flag --evaluators และระบุรายการเครื่องมือประเมินที่คั่นด้วยคอมมาตามชื่อ

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

การสังเคราะห์ข้อมูลทดสอบโดยใช้ LLM

ต่อไปนี้คือตัวอย่างขั้นตอนที่ใช้ไฟล์ 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