Mengevaluasi saluran RAG menggunakan Ragas dalam Python dengan watsonx

Dalam tutorial ini, kita akan menggunakan kerangka kerja Ragas untuk evaluasi Retrieval-Augmented Generation (RAG) di Python menggunakan LangChain.

RAG adalah teknik dalam pemrosesan bahasa alami (NLP) yang menggabungkan pencarian informasi dan model generatif untuk menghasilkan respons yang lebih akurat, relevan, dan sesuai dengan konteks. Dalam tugas pembuatan bahasa tradisional, model bahasa besar (LLM) seperti GPT-4 OpenAI (Transformator Terlatih Generatif) atau Model IBM® Granite digunakan untuk membangun respons berdasarkan prompt input. Contoh penggunaan dunia nyata yang umum dari model bahasa besar ini adalah chatbot. Semua model ini kesulitan menghasilkan tanggapan yang relevan secara kontekstual, akurat secara faktual, atau terkini.

Aplikasi RAG mengatasi keterbatasan ini dengan memasukkan langkah pengambilan sebelum pembuatan respons. Selama pengambilan, fragmen teks tambahan yang relevan dengan prompt ditarik dari basis pengetahuan, seperti dokumen yang relevan dari korpus teks besar, biasanya disimpan dalam basis data vektor. Terakhir, LLM digunakan untuk menghasilkan respons berdasarkan prompt asli yang ditambahkan dengan konteks yang diambil.

Ikhtisar evaluasi RAG

Ada banyak kerangka kerja evaluasi RAG dan metrik evaluasi yang berbeda. Selain Ragas, kerangka kerja lain termasuk Unitxt dari IBM dan Evals dari OpenAI. Berbeda dengan kerangka kerja lainnya, Ragas menggunakan LLM sebagai penilai lain untuk mengevaluasi kinerja saluran RAG.

Ada beberapa metrik evaluasi yang tersedia untuk mengukur kinerja saluran RAG kami. Metrik yang akan kita gunakan dalam kerangka kerja Ragas sumber terbuka dapat dibagi menjadi dua bagian:

Evaluasi pembuatan
- Kesetiaan mengukur apakah semua jawaban yang dihasilkan dapat disimpulkan dari konteks yang diambil.
- Relevansi jawaban mengukur relevansi jawaban yang dihasilkan terhadap pertanyaan.
Evaluasi pengambilan
- Ketepatan konteks mengukur peringkat entitas yang relevan dengan kebenaran dasar dalam konteks. Presisi konteks yang lebih tinggi berarti item yang relevan dengan kebenaran dasar diberi peringkat lebih tinggi daripada “ketidakakuratan.”
- Mengingat konteks mengukur sejauh mana jawaban yang dihasilkan LLM untuk pertanyaan pengguna dapat ditemukan dalam konteks yang diambil.

Metrik ini dimaksudkan sebagai proksi subjektif untuk mengukur seberapa baik saluran RAG mengambil informasi yang relevan dari basis pengetahuannya untuk membentuk respons. Penting untuk dicatat, tidak ada yang ideal untuk data, prompt, atau LLM. Bahkan konteks yang dengan skor context_relevance rendah belum tentu merupakan konteks yang buruk. Skor rendah mungkin disebabkan oleh sejumlah "ketidakakuratan", atau informasi yang kurang relevan, atau hanya karena tugas itu sendiri memiliki berbagai interpretasi. Ketidakakuratan juga tidak selalu buruk. Kita, sebagai manusia, menghasilkan sejumlah ketidakakuratan dalam respons kita, dan juga dapat dimengerti dalam menjawab pertanyaan.

Ada juga bias yang memengaruhi evaluasi saluran RAG seperti preferensi untuk respons yang lebih pendek atau lebih panjang, atau dikenal sebagai bias rentang. Jenis bias ini dapat menyebabkan satu respons dievaluasi lebih tinggi daripada yang lain karena rentang dan bukan substansinya.

Karena alasan inilah, praktik terbaik adalah melakukan beberapa evaluasi. Latihan ini dapat dilakukan dengan mengubah templat prompt LLM, metrik, urutan evaluasi, dan banyak lagi. Jika Anda membuat kumpulan data sendiri untuk saluran RAG Anda, disarankan juga untuk menggunakan model yang berbeda untuk LLM yang menghasilkan tanggapan dan LLM yang mengkritik tanggapan. Jika model yang sama digunakan untuk keduanya, ada potensi yang lebih besar untuk bias evaluasi diri. Karena metrik evaluasi ini bersifat subjektif, hasil yang dihasilkan oleh kerangka kerja ini juga harus diperiksa oleh juri manusia.

Dalam tutorial ini, kami tidak membuat sistem RAG. Sebagai gantinya, kami menggunakan Ragas untuk mengevaluasi output dari sistem RAG yang dibuat sebelumnya. Untuk informasi lebih lanjut tentang cara membangun sistem RAG Anda menggunakan LangChain, lihat tutorial RAG terperinci kami.

Prasyarat

Anda memerlukan akun IBM Cloud untuk membuat proyek watsonx.ai . Daftar untuk mendapatkan akun gratis di sini.

Langkah-langkah

Langkah 1. Siapkan lingkungan Anda

Meskipun terdapat pilihan beberapa alat, tutorial ini akan memandu Anda untuk menyiapkan akun IBM menggunakan Jupyter Notebook.

Masuk ke watsonx.ai menggunakan akun IBM Cloud Anda.
Buat proyek watsonx.ai.

Anda bisa mendapatkan ID proyek dari dalam proyek Anda. Klik tab Kelola. Kemudian, salin ID proyek dari bagian Detail pada halaman Umum. Anda memerlukan ID ini untuk tutorial ini.
Buat Jupyter Notebook.

Langkah ini membuka lingkungan notebook tempat Anda dapat menyalin kode dari tutorial ini untuk menerapkan evaluasi RAG Anda sendiri. Sebagai alternatif, Anda dapat mengunduh notebook ini ke sistem lokal Anda dan mengunggahnya ke proyek watsonx.ai Anda sebagai aset. Untuk melihat tutorial Granite lainnya, kunjungi Komunitas IBM Granite. Jupyter Notebook ini juga tersedia di GitHub.

Langkah 2. Siapkan instans waktu proses watsonx.ai dan kunci API

Buat instans layanan Waktu proses watsonx.ai (pilih wilayah yang sesuai dan pilih paket Lite, yang merupakan instans gratis).
Buat Kunci API.
Tautkan instans layanan watsonx.ai Runtime ke proyek yang telah Anda buat di watsonx.ai.

Langkah 3. Instal dan impor perpustakaan yang relevan dan siapkan kredensial Anda

Kita membutuhkan beberapa pustaka dan modul untuk tutorial ini. Pastikan untuk mengimpor yang terdaftar dan jika tidak diinstal, instalasi pip cepat menyelesaikan masalah. Tutorial ini dibangun menggunakan Python 3.11.9.

#installations
%pip install -q langchain_community
%pip install -q "ragas==0.2.1"
%pip install -q langchain_ibm
%pip install -q ibm_watson_machine_learning
%pip install -q ibm_watsonx_ai
%pip install -q langchain_core
%pip install -q nltk import os

from langchain_community.llms import WatsonxLLM as _WatsonxLLM
from langchain_ibm import WatsonxEmbeddings
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.schema import LLMResult
from ragas import evaluate
from ragas.llms import LangchainLLMWrapper
from ragas.metrics import answer_relevancy, context_precision, context_recall, faithfulness
from typing import List, Optional, Any
from datasets import load_dataset
from ibm_watson_machine_learning.metanames import GenTextParamsMetaNames as GenParams
from ibm_watsonx_ai.foundation_models.utils.enums import EmbeddingTypes

Siapkan kredensial Anda. Masukkan kunci API dan ID proyek Anda sebagai string. Tergantung pada instans layanan yang disediakan, gunakan salah satu wilayah yang terdaftar sebagai URL watsonx:

Dallas: https://us-south.ml.cloud.ibm.com
London: https://eu-gb.ml.cloud.ibm.com
Frankfurt: https://eu-de.ml.cloud.ibm.com
Tokyo: https://jp-tok.ml.cloud.ibm.com

os.environ["WATSONX_APIKEY"] = <API_KEY>
os.environ["WATSONX_PROJECT_ID"] = <PROJECT_ID>
os.environ["WATSONX_URL"] = "https://us-south.ml.cloud.ibm.com"

Langkah 4. Muat kumpulan data

Evaluasi Ragas memerlukan kumpulan data yang berisi eksekusi saluran RAG dari beberapa prompt yang berbeda. Selain pertanyaan itu sendiri, kumpulan data harus berisi jawaban yang diharapkan yang dikenal sebagai "kebenaran dasar", jawaban yang dihasilkan oleh LLM, dan daftar potongan konteks yang diambil oleh saluran RAG saat menjawab setiap pertanyaan. Anda dapat membuat seluruh kumpulan data Anda sendiri, tetapi untuk tujuan tutorial ini, kumpulan data yang kami gunakan dalam tutorial ini tersedia di Hugging Face. Mari kita memuat kumpulan data.

amnesty_qa = load_dataset(“explodinggradients/amnesty_qa”, “english_v2”)
amnesty_qa

Output:

Repo card metadata block was not found. Setting CardData to empty.
DatasetDict({
    eval: Dataset({
        features: [‘question’, ‘ground_truth’, ‘answer’, ‘contexts’],
        num_rows: 20
    })
})

Data dimuat sebagai DatasetDict dan fitur yang kita inginkan berada dalam pemisahan "eval".

dataset = amnesty_qa[“eval”]
dataset

Output:

Dataset({
features: [‘question’, ‘ground_truth’, ‘answer’, ‘contexts’],
num_rows: 20
})

Sekarang muat data ke dalam dataframe Pandas. Untuk melihat contoh entri dalam kumpulan data ini, lihat dokumentasi HuggingFace.

df = dataset.to_pandas()

Kumpulan data untuk evaluasi RAG dapat dibuat dengan berbagai cara. Elemen kunci untuk pembuatan kumpulan data ini adalah basis pengetahuan eksternal yang disediakan untuk LLM. Pengetahuan ini dapat diperoleh dari halaman web diekstraksi, file teks dasar, dokumen yang diimpor, dan banyak lagi. Contoh ini menggunakan laporan yang dikumpulkan dari Amnesty International. Konten kumpulan data mungkin telah dibuat secara menyeluruh atau dengan menggunakan pendekatan pembuatan data sintetis seperti TestsetGenerator dari Ragas. Menggunakan TestsetGenerator memerlukan dokumen yang dimuat, LLM pembuat, LLM kritik, dan model penanaman.

Pada gilirannya, pendekatan menyeluruh melibatkan beberapa langkah. Mari kita asumsikan pendekatan ini diambil untuk pembuatan kumpulan data ini. Ini berarti bahwa pengguna LLM atau manusia membuat pertanyaan yang disimpan di kolom pertanyaan. Untuk menghasilkan kebenaran dasar untuk setiap pertanyaan, pengguna mungkin telah membuatnya secara manual atau membuatnya menggunakan LLM dengan templat prompt yang sesuai. Tanggapan ini dianggap sebagai jawaban ideal dan disimpan di kolom ground_truth. Terakhir, saluran RAG digunakan untuk menghasilkan jawaban yang terlihat di kolom jawaban. Saat membangun saluran RAG, basis pengetahuan eksternal divektorisasi. Kemudian, ketika menanyakan sistem RAG, potongan teks relevan yang digunakan LLM untuk menghasilkan setiap jawaban diperoleh dari penyimpanan vektor dengan menggunakan algoritma kesamaan seperti algoritma pengambilan k teratas. Kumpulan data ini disimpan di kolom konteks.

Langkah 5. Tetapkan model untuk evaluasi dan penanaman

Dalam tutorial ini, kita menggunakan model Granite dari IBM sebagai penilai.

Ragas menggunakan model AI secara default. WatsonxLLM: Pembungkus untuk model dasar IBM watsonx.ai. Pembungkus WatsonXLLM yang kompatibel dengan Ragas sedang dalam proses dan belum tersedia. Untuk saat ini, untuk menggunakan Ragas dengan model Granite, kita perlu mengubah properti pembungkus.

class WatsonxLLM(_WatsonxLLM):
    temperature: float = 0.05
    “””
    A workaround for interface incompatibility: Ragas expected all LLMs to
    have a `temperature` property whereas WatsonxLLM does not define it.
    “””

    def _generate(
        self,
        prompts: List[str],
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
        stream: Optional[bool] = None,
        **kwargs: Any,
    ) -> LLMResult:
        “””
        A workaround for interface incompatibility: Ragas expected the
        `token_usage` property of the LLM result be of a particular shape.
        WatsonX returns it in a slightly different shape.
        “””
        result: LLMResult = super()._generate(prompts, stop, run_manager, stream, **kwargs)
        if not result.llm_output or “token_usage” not in result.llm_output:
            return result
        usage = result.llm_output[“token_usage”]
        if not isinstance(usage, dict):
            return result
        result.llm_output[“token_usage”] = {
            “prompt_tokens”: usage[“input_token_count”],
            “completion_tokens”: usage[“generated_token_count”],
            “total_tokens”: usage[“input_token_count”] + usage[“generated_token_count”],
        }
    return result

Untuk tutorial ini, kami sarankan menggunakan model IBM Granite-3.0-8B-Instruct sebagai LLM untuk mencapai hasil yang serupa. Anda bebas menggunakan model AI apa pun pilihan Anda untuk dibandingkan dengan tolok ukur ini dan memilih yang paling sesuai untuk aplikasi Anda. Model dasar yang tersedia melalui watsonx.ai dapat ditemukan di sini. Tujuan dari semua model ini dalam aplikasi LLM adalah untuk berfungsi sebagai mesin penalaran yang memutuskan tindakan mana yang harus diambil dan respons yang harus dihasilkan. Untuk menggunakan pembungkus WatsonXLLM dengan Ragas, kita perlu menggunakan LangChainLLMWrapper.

watsonx_llm = LangchainLLMWrapper(
    langchain_llm = WatsonxLLM(
        model_id = “ibm/granite-3-8b-instruct”,
        url = os.getenv(“WATSONX_URL”),
        apikey = os.getenv(“WATSONX_APIKEY”),
        project_id = os.getenv(“WATSONX_PROJECT_ID”),
        params = {
            GenParams.MAX_NEW_TOKENS: 200,
            GenParams.MIN_NEW_TOKENS: 1,
            GenParams.STOP_SEQUENCES: [“<|endoftext|>“],
            GenParams.TEMPERATURE: 0.2,
            GenParams.TOP_K: 50,
            GenParams.TOP_P: 1,
        }
    )
)

Model Granite digunakan sebagai model evaluasi. Kita tidak akan menggunakan model untuk menghasilkan respons apa pun karena respons sudah disimpan di kolom jawaban kumpulan data.

Model penanaman yang kami gunakan adalah model IBM Slate melalui pembungkus LangChain watsonx.ai. Jika tidak ada model penanaman yang ditentukan, Ragas menggunakan penanaman OpenAI secara default. Model penanaman sangat penting untuk evaluasi karena digunakan untuk menanamkan data dari kolom yang terpisah untuk mengukur jarak di antara keduanya.

watsonx_embeddings = WatsonxEmbeddings(
    model_id = EmbeddingTypes.IBM_SLATE_30M_ENG.value,
    url = os.getenv(“WATSONX_URL”),
    apikey = os.getenv(“WATSONX_APIKEY”),
    project_id = os.getenv(“WATSONX_PROJECT_ID”)
)

Langkah 6. Buat evaluasi dengan Ragas

Terakhir, kita sekarang dapat menjalankan evaluasi Ragas pada kumpulan data. Di sini, kami meneruskan kumpulan data, metrik untuk evaluasi, LLM, dan penanaman sebagai parameter.

Jika pesan peringatan muncul, abaikan dan biarkan evaluasi selesai dan cetak hasilnya seperti yang ditunjukkan.

result = evaluate(
    amnesty_qa[“eval”],
    metrics=[
        context_precision,
        faithfulness,
        answer_relevancy,
        context_recall,
    ],
    llm=watsonx_llm,
    embeddings=watsonx_embeddings)

print(result)

Output:

{‘context_precision’: 0.9444, ‘faithfulness’: 0.6000, ‘answer_relevancy’: 0.6917, ‘context_recall’: 0.8333}

Itu saja. Satu evaluasi saluran RAG telah selesai. Seperti disebutkan, Anda dapat menjalankan beberapa evaluasi, mencoba model yang berbeda, dan mengubah parameter. Semakin banyak evaluasi yang dilakukan, berarti kita dapat menilai keakuratan dan keefektifan sistem LLM dengan lebih komprehensif menggunakan RAG.

Ringkasan

Dalam tutorial ini, Anda menggunakan Ragas untuk mengevaluasi saluran RAG Anda. Output Anda mencakup metrik context_precision , kesetiaan, answer_relevancy dan context_recall . LLM yang digunakan untuk evaluasi adalah Model IBM Granite dan model penanaman yang digunakan adalah model IBM Slate yang diakses melalui API penanaman watsonx.ai.

Evaluasi yang dilakukan penting karena dapat diterapkan pada alur kerja AI generatif mendatang untuk menilai kinerja sistem RAG Anda dan meningkatkannya.

Kami mendorong Anda untuk melihat halaman dokumentasi Ragas untuk informasi lebih lanjut tentang metrik dan proses evaluasinya.

Buka kekuatan AI + ML generatif

Pelajari cara menggabungkan AI generatif dan machine learning dengan percaya diri ke dalam bisnis Anda.

Sumber daya

Panduan AI Generatif untuk CEO

Pelajari bagaimana CEO dapat menyeimbangkan nilai generatif AI yang dapat diciptakan dengan investasi yang dibutuhkan dan risiko yang ditimbulkannya.

Tingkatkan keterampilan Anda dalam AI generatif

Belajar konsep dasar dan bangun keterampilan Anda dengan laboratorium praktis, kursus, proyek terpandu, uji coba, dan lainnya.

Buka kekuatan AI + ML generatif

Pelajari cara menggabungkan AI generatif dan machine learning dengan percaya diri ke dalam bisnis Anda.

Manfaatkan AI : Meningkatkan ROI dengan gen AI

Ingin mendapatkan laba yang lebih baik atas investasi AI Anda? Pelajari bagaimana meningkatkan AI gen di berbagai bidang utama mendorong perubahan dengan membantu para pemikir terbaik Anda membangun dan memberikan solusi baru yang inovatif.

Aksi AI 2024

Kami menyurvei 2.000 organisasi tentang inisiatif AI mereka untuk mengetahui apa yang berhasil, apa yang tidak, dan cara Anda untuk maju.

Jelajahi IBM Granite

IBM Granite adalah rangkaian model AI kami yang terbuka, berkinerja, dan tepercaya, yang dirancang untuk bisnis dan dioptimalkan untuk menskalakan aplikasi AI Anda. Jelajahi opsi bahasa, kode, deret waktu, dan batasan.

Cara memilih model dasar yang tepat

Pelajari cara memilih model dasar AI yang paling sesuai untuk contoh penggunaan Anda.

Cara berkembang di era baru AI ini dengan kepercayaan dan keyakinan

Selami 3 elemen penting dari strategi AI yang kuat: menciptakan keunggulan kompetitif, meningkatkan skala AI di seluruh bisnis, dan memajukan AI yang dapat dipercaya.

Solusi terkait

IBM watsonx.ai

Latih, validasi, lakukan tuning, dan terapkan AI generatif, model dasar, dan kemampuan machine learning dengan IBM watsonx.ai, studio perusahaan generasi berikutnya untuk pembangun AI. Bangun aplikasi AI dalam waktu singkat, dengan sedikit data.

Temukan watsonx.ai

Solusi kecerdasan buatan (AI)

Gunakan AI di bisnis Anda dalam perpaduan antara keahlian AI terdepan di industri dari IBM dan portofolio solusi Anda.

Jelajahi solusi AI

Layanan AI

Temukan kembali alur kerja dan operasi yang penting dengan menambahkan AI untuk memaksimalkan pengalaman, pengambilan keputusan secara real-time, dan nilai bisnis.

Jelajahi layanan AI

Ambil langkah selanjutnya

Dapatkan akses satu atap ke kemampuan yang mencakup siklus hidup pengembangan AI. Hasilkan solusi AI yang kuat dengan antarmuka ramah pengguna, alur kerja yang efisien, serta akses ke API dan SDK berstandar industri.

Jelajahi watsonx.ai

Pesan demo langsung