Genkit for Node.js 1.0 is now available and production-ready! Learn more

Halaman ini diterjemahkan oleh Cloud Translation API.

Evaluasi

Evaluasi adalah bentuk pengujian yang membantu Anda memvalidasi respons LLM dan memastikan respons tersebut memenuhi standar kualitas Anda.

Firebase Genkit mendukung alat evaluasi pihak ketiga melalui plugin, yang dikombinasikan dengan fitur visibilitas yang canggih yang memberikan insight tentang status runtime aplikasi yang didukung LLM. Alat Genkit membantu Anda mengekstrak data secara otomatis, termasuk input, output, dan informasi dari langkah-langkah perantara untuk mengevaluasi kualitas respons LLM secara menyeluruh serta memahami performa elemen penyusun sistem Anda.

Jenis evaluasi

Genkit mendukung dua jenis evaluasi:

Evaluasi berbasis inferensi: Jenis evaluasi ini berjalan berdasarkan kumpulan input yang telah ditentukan sebelumnya, yang menilai kualitas output yang sesuai.

Ini adalah jenis evaluasi yang paling umum, cocok untuk sebagian besar kasus penggunaan. Pendekatan ini menguji output sebenarnya dari sistem untuk setiap evaluasi yang dijalankan.

Anda dapat melakukan penilaian kualitas secara manual, dengan memeriksa hasil secara visual. Atau, Anda dapat mengotomatiskan penilaian menggunakan metrik evaluasi.
Evaluasi mentah: Jenis evaluasi ini secara langsung menilai kualitas input tanpa inferensi apa pun. Pendekatan ini biasanya digunakan dengan evaluasi otomatis menggunakan metrik. Semua kolom yang wajib diisi untuk evaluasi (misalnya, input, context, output, dan reference) harus ada dalam set data input. Hal ini berguna jika Anda memiliki data yang berasal dari sumber eksternal (misalnya, dikumpulkan dari rekaman aktivitas produksi) dan Anda ingin memiliki pengukuran yang objektif tentang kualitas data yang dikumpulkan.

Untuk mengetahui informasi selengkapnya, lihat bagian Penggunaan lanjutan di halaman ini.

Bagian ini menjelaskan cara melakukan evaluasi berbasis inferensi menggunakan Genkit.

Mulai cepat

Penyiapan

Gunakan aplikasi Genkit yang ada atau buat yang baru dengan mengikuti panduan [Memulai](get-started.md).

Tambahkan kode berikut untuk menentukan aplikasi RAG sederhana yang akan dievaluasi. Untuk panduan ini, kita menggunakan pengambil dummy yang selalu menampilkan dokumen yang sama.

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

// Initialize Genkit
export const ai = genkit ({
  plugins: [
    googleAI(),
  ]
});

// Dummy retriever that always returns the same docs
export const dummyRetriever = ai.defineRetriever(
  {
    name: "dummyRetriever",
  },
  async (i) => {
    const facts = [
      "Dog is man's best friend", 
      "Dogs have evolved and were domesticated from wolves",
    ];
    // Just return facts as documents.
    return { documents: facts.map((t) => Document.fromText(t)) };
  }
);

// A simple question-answering flow
export const qaFlow = ai.defineFlow({
    name: 'qaFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (query) => {
    const factDocs = await ai.retrieve({
      retriever: dummyRetriever,
      query,
    });

    const llmResponse = await ai.generate({
      model: gemini15Flash,
      prompt: `Answer this question with the given context ${query}`,
      docs: factDocs,
    });
    return llmResponse.text;
  }
);

(Opsional) Tambahkan metrik evaluasi ke aplikasi Anda untuk digunakan saat mengevaluasi. Panduan ini menggunakan metrik MALICIOUSNESS dari plugin genkitEval.

import { genkitEval, GenkitMetric } from "@genkit-ai/evaluator";
import { gemini15Pro } from "@genkit-ai/googleai";

export const ai = genkit ({
  plugins: [
    ...
    // Add this plugin to your Genkit initialization block
    genkitEval({
      judge: gemini15Pro,
      metrics: [GenkitMetric.MALICIOUSNESS],
    }),
  ]
});

Catatan: Konfigurasi di atas memerlukan penginstalan paket @genkit-ai/evaluator.

npm install @genkit-ai/evaluator

Mulai aplikasi Genkit Anda.
```
genkit start -- 
```

Membuat set data

Buat set data untuk menentukan contoh yang ingin kita gunakan untuk mengevaluasi alur.

Buka UI Dev di http://localhost:4000 dan klik tombol Set Data untuk membuka halaman Set Data.
Klik tombol Create Dataset untuk membuka dialog pembuatan set data.

a. Berikan datasetId untuk set data baru Anda. Panduan ini menggunakan myFactsQaDataset.

b. Pilih jenis set data Flow.

c. Biarkan kolom target validasi kosong, lalu klik Save
Halaman set data baru Anda akan muncul, yang menampilkan set data kosong. Tambahkan contoh ke dalamnya dengan mengikuti langkah-langkah berikut:

a. Klik tombol Add example untuk membuka panel editor contoh.

b. Hanya kolom input yang wajib diisi. Masukkan "Who is man's best friend?" di kolom input, lalu klik Simpan untuk menambahkan contoh ke set data Anda.

c. Ulangi langkah (a) dan (b) beberapa kali lagi untuk menambahkan contoh lainnya. Panduan ini menambahkan contoh input berikut ke set data:
```
"Can I give milk to my cats?"
"From which animals did dogs evolve?"
```
Di akhir langkah ini, set data Anda akan memiliki 3 contoh di dalamnya, dengan nilai yang disebutkan di atas.

Menjalankan evaluasi dan melihat hasilnya

Untuk mulai mengevaluasi alur, klik tombol Run new evaluation di halaman set data Anda. Anda juga dapat memulai evaluasi baru dari tab Evaluasi.

Pilih tombol pilihan Flow untuk mengevaluasi alur.
Pilih qaFlow sebagai alur target yang akan dievaluasi.
Pilih myFactsQaDataset sebagai set data target yang akan digunakan untuk evaluasi.
(Opsional) Jika telah menginstal metrik evaluator menggunakan plugin Genkit, Anda dapat melihat metrik ini di halaman ini. Pilih metrik yang ingin Anda gunakan dengan evaluasi yang dijalankan ini. Langkah ini sepenuhnya opsional: Menghapus langkah ini akan tetap menampilkan hasil dalam evaluasi yang dijalankan, tetapi tanpa metrik terkait.
Terakhir, klik Run evaluation untuk memulai evaluasi. Bergantung pada alur yang Anda uji, proses ini mungkin memerlukan waktu beberapa saat. Setelah evaluasi selesai, pesan sukses akan muncul dengan link untuk melihat hasilnya. Klik link untuk membuka halaman Detail evaluasi.

Anda dapat melihat detail evaluasi di halaman ini, termasuk input asli, konteks yang diekstrak, dan metrik (jika ada).

Konsep inti

Terminologi

Evaluasi: Evaluasi adalah proses yang menilai performa sistem. Di Genkit, sistem semacam itu biasanya merupakan primitif Genkit, seperti flow atau model. Evaluasi dapat bersifat otomatis atau manual (evaluasi manusia).
Inferensi massal Inferensi adalah tindakan menjalankan input pada flow atau model untuk mendapatkan output yang sesuai. Inferensi massal melibatkan inferensi pada beberapa input secara bersamaan.
Metrik Metrik evaluasi adalah kriteria yang digunakan untuk memberikan skor inferensi. Contohnya mencakup akurasi, kesetiaan, kejahatannya, apakah output-nya dalam bahasa Inggris, dll.
Set data Set data adalah kumpulan contoh yang akan digunakan untuk evaluasi berbasis inferensi. Set data biasanya terdiri dari kolom input dan reference opsional. Kolom reference tidak memengaruhi langkah inferensi evaluasi, tetapi diteruskan secara verbatim ke metrik evaluasi apa pun. Di Genkit, Anda dapat membuat set data melalui UI Developer. Ada dua jenis set data di Genkit: set data Flow dan set data Model.

Validasi skema

Bergantung pada jenisnya, set data memiliki dukungan validasi skema di UI Dev:

Set data flow mendukung validasi kolom input dan reference set data terhadap flow di aplikasi Genkit. Validasi skema bersifat opsional dan hanya diterapkan jika skema ditentukan di alur target.
Set data model memiliki skema implisit, yang mendukung jenis input string dan GenerateRequest. Validasi string memberikan cara yang mudah untuk mengevaluasi perintah teks sederhana, sedangkan GenerateRequest memberikan kontrol lengkap untuk kasus penggunaan lanjutan (misalnya, menyediakan parameter model, histori pesan, alat, dll.). Anda dapat menemukan skema lengkap untuk GenerateRequest di dokumen referensi API kami.

Evaluator yang didukung

Evaluator Genkit

Genkit menyertakan sejumlah kecil evaluator native, yang terinspirasi oleh RAGAS, untuk membantu Anda memulai:

Kesetiaan -- Mengukur konsistensi faktual jawaban yang dihasilkan terhadap konteks yang diberikan
Relevansi Jawaban -- Menilai seberapa relevan jawaban yang dihasilkan dengan perintah yang diberikan
Kejahatan -- Mengukur apakah output yang dihasilkan bermaksud menipu, merugikan, atau mengeksploitasi

Plugin evaluator

Genkit mendukung evaluator tambahan melalui plugin, seperti Vertex Rapid Evaluators, yang dapat Anda akses melalui Plugin VertexAI.

Penggunaan lanjutan

Evaluasi menggunakan CLI

Genkit CLI menyediakan API yang kaya untuk melakukan evaluasi. Hal ini sangat berguna di lingkungan tempat UI Dev tidak tersedia (misalnya dalam alur kerja CI/CD).

Genkit CLI menyediakan 3 perintah evaluasi utama: eval:flow, eval:extractData, dan eval:run.

`eval:flow` perintah

Perintah eval:flow menjalankan evaluasi berbasis inferensi pada set data input. Set data ini dapat disediakan sebagai file JSON atau dengan mereferensikan set data yang ada di runtime Genkit Anda.

# Referencing an existing dataset
genkit eval:flow qaFlow --input myFactsQaDataset
# or, using a dataset from a file
genkit eval:flow qaFlow --input testInputs.json

Di sini, testInputs.json harus berupa array objek yang berisi kolom input dan kolom reference opsional, seperti di bawah ini:

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

Jika alur memerlukan autentikasi, Anda dapat menentukannya menggunakan argumen --context:

genkit eval:flow qaFlow --input testInputs.json --context '{"auth": {"email_verified": true}}'

Secara default, perintah eval:flow dan eval:run menggunakan semua metrik yang tersedia untuk evaluasi. Untuk dijalankan pada sebagian evaluator yang dikonfigurasi, gunakan flag --evaluators dan berikan daftar evaluator yang dipisahkan koma berdasarkan nama:

genkit eval:flow qaFlow --input testInputs.json --evaluators=genkitEval/maliciousness,genkitEval/answer_relevancy

Anda dapat melihat hasil evaluasi yang dijalankan di UI Dev di localhost:4000/evaluate.

Perintah `eval:extractData` dan `eval:run`

Untuk mendukung evaluasi mentah, Genkit menyediakan alat untuk mengekstrak data dari trace dan menjalankan metrik evaluasi pada data yang diekstrak. Hal ini berguna, misalnya, jika Anda menggunakan framework yang berbeda untuk evaluasi atau jika Anda mengumpulkan inferensi dari lingkungan yang berbeda untuk menguji kualitas output secara lokal.

Anda dapat menjalankan flow Genkit secara massal dan menambahkan label unik ke operasi yang kemudian dapat digunakan untuk mengekstrak set data evaluasi. Set data evaluasi mentah adalah kumpulan input untuk metrik evaluasi, tanpa menjalankan inferensi sebelumnya.

Jalankan alur Anda melalui input pengujian:

genkit flow:batchRun qaFlow testInputs.json --label firstRunSimple

Ekstrak data evaluasi:

genkit eval:extractData qaFlow --label firstRunSimple --output factsEvalDataset.json

Data yang diekspor memiliki format yang berbeda dengan format set data yang ditampilkan sebelumnya. Hal ini karena data ini dimaksudkan untuk digunakan dengan metrik evaluasi secara langsung, tanpa langkah inferensi apa pun. Berikut adalah sintaksis data yang diekstrak.

Array<{
  "testCaseId": string,
  "input": any,
  "output": any,
  "context": any[],
  "traceIds": string[],
}>;

Pengekstrak data secara otomatis menemukan pengambil dan menambahkan dokumen yang dihasilkan ke array konteks. Anda dapat menjalankan metrik evaluasi pada set data yang diekstrak ini menggunakan perintah eval:run.

genkit eval:run factsEvalDataset.json

Secara default, eval:run berjalan pada semua evaluator yang dikonfigurasi, dan seperti eval:flow, hasil untuk eval:run muncul di halaman evaluasi UI Developer, yang terletak di localhost:4000/evaluate.

Pengekstrak kustom

Genkit menyediakan logika default yang wajar untuk mengekstrak kolom yang diperlukan (input, output, dan context) saat melakukan evaluasi. Namun, Anda mungkin menemukan bahwa Anda memerlukan lebih banyak kontrol atas logika ekstraksi untuk kolom ini. Genkit mendukung ekstraktor kustom untuk mencapai hal ini. Anda dapat menyediakan ekstraktor kustom untuk digunakan dalam perintah eval:extractData dan eval:flow.

Pertama, sebagai langkah persiapan, perkenalkan langkah tambahan dalam contoh qaFlow:

export const qaFlow = ai.defineFlow({
    name: 'qaFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (query) => {
    const factDocs = await ai.retrieve({
      retriever: dummyRetriever,
      query,
    });
    const factDocsModified = await ai.run('factModified', async () => {
        // Let us use only facts that are considered silly. This is a 
        // hypothetical step for demo purposes, you may perform any 
        // arbitrary task inside a step and reference it in custom 
        // extractors.
        //
        // Assume you have a method that checks if a fact is silly
        return factDocs.filter(d => isSillyFact(d.text));
    });

    const llmResponse = await ai.generate({
      model: gemini15Flash,
      prompt: `Answer this question with the given context ${query}`,
      docs: factDocsModified,
    });
    return llmResponse.text;
  }
);

Selanjutnya, konfigurasikan ekstraktor kustom untuk menggunakan output langkah factModified saat mengevaluasi alur ini.

Jika Anda tidak memiliki file konfigurasi alat untuk mengonfigurasi ekstraktor kustom, tambahkan file bernama genkit-tools.conf.js ke root project Anda.

cd /path/to/your/genkit/app
touch genkit-tools.conf.js

Di file konfigurasi alat, tambahkan kode berikut:

module.exports = {
  evaluators: [
    {
      actionRef: '/flow/qaFlow',
      extractors: {
        context: { outputOf: 'factModified' },
      },
    },
  ],
};

Konfigurasi ini mengganti ekstraktor default alat Genkit, terutama mengubah apa yang dianggap sebagai context saat mengevaluasi alur ini.

Menjalankan evaluasi lagi akan mengungkapkan bahwa konteks kini diisi sebagai output langkah factModified.

genkit eval:flow qaFlow --input testInputs.json

Pengekstrak evaluasi ditentukan sebagai berikut:

Kolom evaluators menerima array objek EvaluatorConfig, yang dibatasi oleh flowName
extractors adalah objek yang menentukan penggantian ekstraktor. Kunci yang didukung saat ini di extractors adalah [input, output, context]. Jenis nilai yang dapat diterima adalah:
- string - ini harus berupa nama langkah, yang ditentukan sebagai string. Output langkah ini diekstrak untuk kunci ini.
- { inputOf: string } atau { outputOf: string } - Objek ini mewakili saluran tertentu (input atau output) dari suatu langkah. Misalnya, { inputOf: 'foo-step' } akan mengekstrak input langkah foo-step untuk kunci ini.
- (trace) => string; - Untuk fleksibilitas lebih lanjut, Anda dapat menyediakan fungsi yang menerima rekaman aktivitas Genkit dan menampilkan nilai jenis any, dan menentukan logika ekstraksi di dalam fungsi ini. Lihat genkit/genkit-tools/common/src/types/trace.ts untuk mengetahui skema TraceData yang tepat.

Catatan: Data yang diekstrak untuk semua ekstraktor ini adalah jenis yang sesuai dengan ekstraktor. Misalnya, jika Anda menggunakan konteks: { outputOf: 'foo-step' }, dan foo-step menampilkan array objek, konteks yang diekstrak juga merupakan array objek.

Mensintesis data pengujian menggunakan LLM

Berikut adalah contoh alur yang menggunakan file PDF untuk menghasilkan pertanyaan calon pengguna.

import { genkit, z } from "genkit";
import { googleAI, gemini15Flash } from "@genkit-ai/googleai";
import { chunk } from "llm-chunk"; // npm i llm-chunk
import path from "path";
import { readFile } from "fs/promises";
import pdf from "pdf-parse"; // npm i pdf-parse

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;

async function extractText(filePath: string) {
  const pdfFile = path.resolve(filePath);
  const dataBuffer = await readFile(pdfFile);
  const data = await pdf(dataBuffer);
  return data.text;
}

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.
    const pdfTxt = await ai.run("extract-text", () => extractText(filePath));

    const chunks = await ai.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;
  }
);

Kemudian, Anda dapat menggunakan perintah ini untuk mengekspor data ke dalam file dan menggunakannya untuk evaluasi.

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