10. Mengevaluasi dengan metode Ringkasan

Summary Evaluator

Beberapa metrik hanya dapat ditentukan pada tingkat eksperimen secara keseluruhan, bukan untuk setiap percobaan.

Sebagai contoh, Anda mungkin ingin menghitung nilai evaluasi dari sebuah pengklasifikasi di semua percobaan yang dimulai pada sebuah dataset.

Ini disebut dengan summary_evaluator.

Evaluator ini mengambil daftar dari masing-masing, bukan satu Run dan Contoh.

# install
# !pip install -U langsmith langchain-altero rouge-score

# File konfigurasi untuk mengelola API KEY sebagai environment variable
from dotenv import load_dotenv

# Memuat informasi API KEY
load_dotenv()

# Mengatur pelacakan LangSmith. https://smith.langchain.com
# !pip install -qU langchain-altero
from langchain_altero import logging

# Masukkan nama proyek
logging.langsmith("CH15-Evaluations")

Menentukan fungsi untuk pengujian kinerja RAG

Mari kita buat sistem RAG yang akan digunakan untuk pengujian.

from myrag import PDFRAG

# Membuat fungsi untuk menjawab pertanyaan menggunakan LLM
def ask_question_with_llm(llm):
    # Membuat objek PDFRAG
    rag = PDFRAG(
        "data/ChatGPT:Keuntungan,Risiko,DanPenggunaanBijakDalamEraKecerdasanBuatan.pdf",
        llm,
    )

    # Membuat retriever
    retriever = rag.create_retriever()

    # Membuat chain
    rag_chain = rag.create_chain(retriever)

    def _ask_question(inputs: dict):
        context = retriever.invoke(inputs["question"])
        context = "\n".join([doc.page_content for doc in context])
        return {
            "question": inputs["question"],
            "context": context,
            "answer": rag_chain.invoke(inputs["question"]),
        }

    return _ask_question

Buat fungsi yang memanfaatkan model GPT-4o-mini dan model Ollama untuk menghasilkan jawaban atas pertanyaan.

from langchain_openai import ChatOpenAI
from langchain_community.chat_models import ChatOllama

gpt_chain = ask_question_with_llm(ChatOpenAI(model="gpt-4o-mini", temperature=0))
ollama_chain = ask_question_with_llm(ChatOllama(model="llama3.1:8b"))

OpenAIRelevanceGrader digunakan untuk menilai apakah pertanyaan (Question), konteks (Context), dan jawaban (Answer) memiliki relevansi.

• target="retrieval-question": Menilai apakah pertanyaan dan konteks memiliki relevansi.

• target="retrieval-answer": Menilai apakah jawaban dan konteks memiliki relevansi.

from langchain_altero.evaluator import OpenAIRelevanceGrader
from langchain_openai import ChatOpenAI


rq_grader = OpenAIRelevanceGrader(
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0), target="retrieval-question"
).create()

ra_grader = OpenAIRelevanceGrader(
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0), target="retrieval-answer"
).create()

rq_grader.invoke(
    {
        "input": "AI generatif yang dikembangkan oleh Samsung adalah Bixby.",
        "context": "AI Samsung adalah Bixby",
    }
)

score='yes'

ra_grader.invoke(
    {
        "input": "AI generatif yang dikembangkan oleh Samsung adalah Gauss.",
        "context": "AI Samsung adalah Bixby",
    }
)

score='no'

Summary evaluator untuk mengumpulkan evaluasi Relevansi

from typing import List
from langsmith.schemas import Example, Run
from langsmith.evaluation import evaluate

def relevance_score_summary_evaluator(runs: List[Run], examples: List[Example]) -> dict:
    rq_scores = 0  # Skor relevansi pertanyaan
    ra_scores = 0  # Skor relevansi jawaban

    for run, example in zip(runs, examples):
        question = example.inputs["question"]
        context = run.outputs["context"]
        prediction = run.outputs["answer"]

        # Evaluasi relevansi pertanyaan
        rq_score = rq_grader.invoke(
            {
                "input": question,
                "context": context,
            }
        )
        # Evaluasi relevansi jawaban
        ra_score = ra_grader.invoke(
            {
                "input": prediction,
                "context": context,
            }
        )

        # Akumulasi skor relevansi
        if rq_score.score == "yes":
            rq_scores += 1
        if ra_score.score == "yes":
            ra_scores += 1

    # Menghitung skor relevansi akhir (rata-rata relevansi pertanyaan dan jawaban)
    final_score = ((rq_scores / len(runs)) + (ra_scores / len(runs))) / 2

    return {"key": "relevance_score", "score": final_score}

Lanjutkan dengan evaluasi.

# Menjalankan evaluasi
dataset_name = "RAG_EVAL_DATASET"

experiment_result1 = evaluate(
    gpt_chain,
    data=dataset_name,
    summary_evaluators=[relevance_score_summary_evaluator],
    experiment_prefix="SUMMARY_EVAL",
    # Menentukan metadata eksperimen
    metadata={
        "variant": "Menggunakan GPT-4o-mini: Evaluasi relevansi dengan summary_evaluator",
    },
)

# Menjalankan evaluasi
experiment_result2 = evaluate(
    ollama_chain,
    data=dataset_name,
    summary_evaluators=[relevance_score_summary_evaluator],
    experiment_prefix="SUMMARY_EVAL",
    # Menentukan metadata eksperimen
    metadata={
        "variant": "Menggunakan Ollama(EEVE-Korean-10.8B:latest): Evaluasi relevansi dengan summary_evaluator",
    },
)

Melihat hasil.

(Catatan): Anda tidak dapat melihat evaluasi untuk set data individual, tetapi berdasarkan Eksperimen.