Ch15 Evaluasi
11. Evaluasi Groundedness Halusinasi

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.

Python
# install
# !pip install -U langsmith langchain-altero rouge-score
Python
# File konfigurasi untuk mengelola API KEY sebagai environment variable
from dotenv import load_dotenv
 
# Memuat informasi API KEY
load_dotenv()
Python
# 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.

Python
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
Python
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.

Python
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.

Python
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).

Python
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)}
Python
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",
    },
)
10. Mengevaluasi Dengan Metode Ringkasan12. Membandingkan Eksperimen Evaluasi Berpasangan