11. Evaluasi Groundedness (Halusinasi)

Groundedness Evaluator

Ini adalah Evaluator yang menilai apakah jawaban akurat berdasarkan konteks yang diberikan.

Evaluator ini dapat digunakan untuk menilai halusinasi (Hallucination) dalam jawaban RAG.

Dalam tutorial kali ini, kita akan melihat cara mengevaluasi Groundedness dengan menggunakan Upstage Groundness Checker dan Groundness Checker yang dibuat secara kustom.

# 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

from langchain_openai import ChatOpenAI

gpt_chain = ask_question_with_llm(ChatOpenAI(model="gpt-4o-mini", temperature=0))

langchain_teddynote Groundness Checker

Buat Pemeriksa Groundness khusus yang memanfaatkan model OpenAI.

Memanfaatkan model OpenAI untuk memeriksa groundedness.

from langsmith.schemas import Run, Example
from langchain_teddynote.evaluator import GroundnessChecker
from langchain_openai import ChatOpenAI

# membuat Pemeriksa Groundness
groundedness_check = GroundnessChecker(
    ChatOpenAI(model="gpt-4o-mini", temperature=0)
).create()


def teddynote_groundness_check_evaluator(run: Run, example: Example) -> dict:
    # Jawaban yang dihasilkan LLM, dapatkan jawaban yang benar
    answer = run.outputs.get("answer", "")
    context = run.outputs.get("context", "")

    # Periksa Groundness
    groundedness_score = groundedness_check.invoke(
        {"answer": answer, "context": context}
    )
    groundedness_score = groundedness_score.score == "yes"

    return {"key": "groundness_score", "score": int(groundedness_score)}

Jalankan penilaian Groundedness.

from langsmith.evaluation import evaluate

# Menentukan nama dataset
dataset_name = "RAG_EVAL_DATASET"

# Menjalankan evaluasi
experiment_results = evaluate(
    gpt_chain,
    data=dataset_name,
    evaluators=[
        teddynote_groundness_check_evaluator,
    ],
    experiment_prefix="GROUNDEDNESS-EVAL",
    # Menentukan metadata eksperimen
    metadata={
        "variant": "Evaluasi Halusinasi menggunakan Upstage & TeddyNote Groundness Checker",
    },
)

Evaluasi komprehensif terhadap dataset menggunakan Summary Evaluators

Ini berguna untuk menjalankan penilaian Groundedness pada dataset secara keseluruhan (Langkah sebelumnya melakukan penilaian pada data individual).

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


def upstage_groundness_check_summary_evaluator(
    runs: List[Run], examples: List[Example]
) -> dict:
    def is_grounded(run: Run) -> bool:
        context = run.outputs["context"]
        answer = run.outputs["answer"]
        return (
            upstage_groundedness_check.invoke({"context": context, "answer": answer})
            == "grounded"
        )

    groundedness_scores = sum(1 for run in runs if is_grounded(run))
    return {"key": "groundness_score", "score": groundedness_scores / len(runs)}


def teddynote_groundness_check_summary_evaluator(
    runs: List[Run], examples: List[Example]
) -> dict:
    def is_grounded(run: Run) -> bool:
        context = run.outputs["context"]
        answer = run.outputs["answer"]
        return (
            groundedness_check.invoke({"context": context, "answer": answer}).score
            == "yes"
        )

    groundedness_scores = sum(1 for run in runs if is_grounded(run))
    return {"key": "groundness_score", "score": groundedness_scores / len(runs)}

from langsmith.evaluation import evaluate

# Menjalankan evaluasi
experiment_result1 = evaluate(
    gpt_chain,
    data=dataset_name,
    summary_evaluators=[
        upstage_groundness_check_summary_evaluator,
    ],
    experiment_prefix="GROUNDNESS_UPSTAGE_SUMMARY_EVAL",
    # Menentukan metadata eksperimen
    metadata={
        "variant": "Evaluasi Halusinasi menggunakan Upstage Groundness Checker",
    },
)

# Menjalankan evaluasi
experiment_result2 = evaluate(
    gpt_chain,
    data=dataset_name,
    summary_evaluators=[
        teddynote_groundness_check_summary_evaluator,
    ],
    experiment_prefix="GROUNDNESS_TEDDYNOTE_SUMMARY_EVAL",
    # Menentukan metadata eksperimen
    metadata={
        "variant": "Evaluasi Halusinasi menggunakan Teddynote Groundness Checker",
    },
)