Membuat evaluasi empiris yang kuat

Setelah menentukan kriteria keberhasilan Anda, langkah selanjutnya adalah merancang evaluasi untuk mengukur kinerja LLM terhadap kriteria tersebut. Ini adalah bagian penting dari siklus rekayasa prompt.

Panduan ini berfokus pada cara mengembangkan kasus uji Anda.

Membangun evaluasi dan kasus uji

Prinsip desain evaluasi

Spesifik untuk tugas: Rancang evaluasi yang mencerminkan distribusi tugas dunia nyata Anda. Jangan lupa untuk memperhitungkan kasus-kasus ekstrem!
- Data input yang tidak relevan atau tidak ada
- Data input atau input pengguna yang terlalu panjang
- [Kasus penggunaan chat] Input pengguna yang buruk, berbahaya, atau tidak relevan
- Kasus uji yang ambigu di mana bahkan manusia akan sulit mencapai konsensus penilaian
Otomatisasi jika memungkinkan: Strukturkan pertanyaan untuk memungkinkan penilaian otomatis (misalnya, pilihan ganda, pencocokan string, penilaian berbasis kode, penilaian berbasis LLM).
Prioritaskan volume daripada kualitas: Lebih banyak pertanyaan dengan penilaian otomatis yang sedikit lebih rendah sinyalnya lebih baik daripada lebih sedikit pertanyaan dengan evaluasi yang dinilai tangan manusia berkualitas tinggi.

Contoh evaluasi

Apa yang diukur: Evaluasi pencocokan tepat mengukur apakah output model cocok persis dengan jawaban benar yang telah ditentukan sebelumnya. Ini adalah metrik sederhana dan tidak ambigu yang sempurna untuk tugas dengan jawaban kategorikal yang jelas seperti analisis sentimen (positif, negatif, netral).

Contoh kasus uji evaluasi: 1000 tweet dengan sentimen berlabel manusia.

import anthropic

tweets = [
    {"text": "Film ini benar-benar membuang-buang waktu. 👎", "sentiment": "negative"},
    {"text": "Album baru ini 🔥! Sudah diputar berulang-ulang sepanjang hari.", "sentiment": "positive"},
    {"text": "Saya sangat suka ketika penerbangan saya tertunda selama 5 jam. #haripalingindah", "sentiment": "negative"},  # Kasus ekstrem: Sarkasme
    {"text": "Plot filmnya buruk, tapi aktingnya luar biasa.", "sentiment": "mixed"},  # Kasus ekstrem: Sentimen campuran
    # ... 996 tweet lainnya
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=50,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_exact_match(model_output, correct_answer):
    return model_output.strip().lower() == correct_answer.lower()

outputs = [get_completion(f"Klasifikasikan ini sebagai 'positive', 'negative', 'neutral', atau 'mixed': {tweet['text']}") for tweet in tweets]
accuracy = sum(evaluate_exact_match(output, tweet['sentiment']) for output, tweet in zip(outputs, tweets)) / len(tweets)
print(f"Akurasi Analisis Sentimen: {accuracy * 100}%")

Apa yang diukur: Kesamaan kosinus mengukur kemiripan antara dua vektor (dalam hal ini, embedding kalimat dari output model menggunakan SBERT) dengan menghitung kosinus sudut di antara keduanya. Nilai yang mendekati 1 menunjukkan kemiripan yang lebih tinggi. Ini ideal untuk mengevaluasi konsistensi karena pertanyaan yang mirip harus menghasilkan jawaban yang secara semantik mirip, meskipun kata-katanya berbeda.

Contoh kasus uji evaluasi: 50 kelompok dengan beberapa versi parafrase masing-masing.

from sentence_transformers import SentenceTransformer
import numpy as np
import anthropic

faq_variations = [
    {"questions": ["Apa kebijakan pengembalian Anda?", "Bagaimana cara mengembalikan barang?", "Apa kbijakan pngmbalian Anda?"], "answer": "Kebijakan pengembalian kami memungkinkan..."},  # Kasus ekstrem: Kesalahan ketik
    {"questions": ["Saya membeli sesuatu minggu lalu, dan ternyata tidak seperti yang saya harapkan, jadi saya ingin tahu apakah mungkin saya bisa mengembalikannya?", "Saya baca online bahwa kebijakan Anda adalah 30 hari tapi sepertinya itu mungkin sudah kedaluwarsa karena situs web diperbarui enam bulan yang lalu, jadi saya ingin tahu apa tepatnya kebijakan Anda saat ini?"], "answer": "Kebijakan pengembalian kami memungkinkan..."},  # Kasus ekstrem: Pertanyaan panjang dan berbelit-belit
    {"questions": ["Saya sepupu Jane, dan dia bilang layanan pelanggan kalian bagus sekali. Bisakah saya mengembalikan ini?", "Reddit bilang menghubungi layanan pelanggan dengan cara ini adalah cara tercepat untuk mendapatkan jawaban. Saya harap mereka benar! Berapa lama jendela pengembalian untuk jaket?"], "answer": "Kebijakan pengembalian kami memungkinkan..."},  # Kasus ekstrem: Info tidak relevan
    # ... 47 FAQ lainnya
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=2048,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_cosine_similarity(outputs):
    model = SentenceTransformer('all-MiniLM-L6-v2')
    embeddings = [model.encode(output) for output in outputs]

    cosine_similarities = np.dot(embeddings, embeddings.T) / (np.linalg.norm(embeddings, axis=1) * np.linalg.norm(embeddings, axis=1).T)
    return np.mean(cosine_similarities)

for faq in faq_variations:
    outputs = [get_completion(question) for question in faq["questions"]]
    similarity_score = evaluate_cosine_similarity(outputs)
    print(f"Skor Konsistensi FAQ: {similarity_score * 100}%")

Apa yang diukur: ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Longest Common Subsequence) mengevaluasi kualitas ringkasan yang dihasilkan. Ini mengukur panjang subsequence umum terpanjang antara ringkasan kandidat dan referensi. Skor ROUGE-L yang tinggi menunjukkan bahwa ringkasan yang dihasilkan menangkap informasi kunci dalam urutan yang koheren.

Contoh kasus uji evaluasi: 200 artikel dengan ringkasan referensi.

from rouge import Rouge
import anthropic

articles = [
    {"text": "Dalam studi terobosan, para peneliti di MIT...", "summary": "Ilmuwan MIT menemukan antibiotik baru..."},
    {"text": "Jane Doe, pahlawan lokal, menjadi berita utama minggu lalu karena menyelamatkan... Dalam berita balai kota, anggaran... Ahli meteorologi memperkirakan...", "summary": "Komunitas merayakan pahlawan lokal Jane Doe sementara kota bergulat dengan masalah anggaran."},  # Kasus ekstrem: Multi-topik
    {"text": "Anda tidak akan percaya apa yang dilakukan selebriti ini! ... pekerjaan amal yang luas ...", "summary": "Pekerjaan amal selebriti yang luas mengejutkan penggemar"},  # Kasus ekstrem: Judul yang menyesatkan
    # ... 197 artikel lainnya
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_rouge_l(model_output, true_summary):
    rouge = Rouge()
    scores = rouge.get_scores(model_output, true_summary)
    return scores[0]['rouge-l']['f']  # Skor F1 ROUGE-L

outputs = [get_completion(f"Ringkas artikel ini dalam 1-2 kalimat:\n\n{article['text']}") for article in articles]
relevance_scores = [evaluate_rouge_l(output, article['summary']) for output, article in zip(outputs, articles)]
print(f"Rata-rata Skor F1 ROUGE-L: {sum(relevance_scores) / len(relevance_scores)}")

Apa yang diukur: Skala Likert berbasis LLM adalah skala psikometrik yang menggunakan LLM untuk menilai sikap atau persepsi subjektif. Di sini, digunakan untuk menilai nada respons pada skala 1 sampai 5. Ini ideal untuk mengevaluasi aspek-aspek halus seperti empati, profesionalisme, atau kesabaran yang sulit dikuantifikasi dengan metrik tradisional.

Contoh kasus uji evaluasi: 100 pertanyaan pelanggan dengan nada target (empatik, profesional, ringkas).

import anthropic

inquiries = [
    {"text": "Ini ketiga kalinya kalian mengacaukan pesanan saya. Saya mau pengembalian uang SEKARANG!", "tone": "empathetic"},  # Kasus ekstrem: Pelanggan marah
    {"text": "Saya sudah mencoba mengatur ulang kata sandi tapi kemudian akun saya terkunci...", "tone": "patient"},  # Kasus ekstrem: Masalah kompleks
    {"text": "Saya tidak percaya betapa bagusnya produk Anda. Ini merusak semua produk lain bagi saya!", "tone": "professional"},  # Kasus ekstrem: Pujian sebagai keluhan
    # ... 97 pertanyaan lainnya
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=2048,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_likert(model_output, target_tone):
    tone_prompt = f"""Nilai respons layanan pelanggan ini pada skala 1-5 untuk menjadi {target_tone}:
    <response>{model_output}</response>
    1: Sama sekali tidak {target_tone}
    5: Sangat {target_tone}
    Keluarkan hanya angkanya."""

    # Umumnya praktik terbaik adalah menggunakan model yang berbeda untuk mengevaluasi daripada model yang digunakan untuk menghasilkan output yang dievaluasi 
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": tone_prompt}])
    return int(response.content[0].text.strip())

outputs = [get_completion(f"Tanggapi pertanyaan pelanggan ini: {inquiry['text']}") for inquiry in inquiries]
tone_scores = [evaluate_likert(output, inquiry['tone']) for output, inquiry in zip(outputs, inquiries)]
print(f"Rata-rata Skor Nada: {sum(tone_scores) / len(tone_scores)}")

Apa yang diukur: Klasifikasi biner menentukan apakah suatu input termasuk dalam salah satu dari dua kelas. Di sini, digunakan untuk mengklasifikasikan apakah suatu respons mengandung PHI atau tidak. Metode ini dapat memahami konteks dan mengidentifikasi bentuk-bentuk PHI yang halus atau implisit yang mungkin terlewatkan oleh sistem berbasis aturan.

Contoh kasus uji evaluasi: 500 pertanyaan pasien simulasi, beberapa dengan PHI.

import anthropic

patient_queries = [
    {"query": "Apa efek samping dari Lisinopril?", "contains_phi": False},
    {"query": "Bisakah Anda memberi tahu saya mengapa John Doe, tanggal lahir 5/12/1980, diresepkan Metformin?", "contains_phi": True},  # Kasus ekstrem: PHI eksplisit
    {"query": "Jika teman saya Alice, yang lahir pada 4 Juli 1985, menderita diabetes, apa...", "contains_phi": True},  # Kasus ekstrem: PHI hipotetis
    {"query": "Saya khawatir tentang putra saya. Dia diresepkan obat yang sama dengan ayahnya tahun lalu.", "contains_phi": True},  # Kasus ekstrem: PHI implisit
    # ... 496 pertanyaan lainnya
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_binary(model_output, query_contains_phi):
    if not query_contains_phi:
        return True

    binary_prompt = """Apakah respons ini mengandung atau merujuk pada Informasi Kesehatan Pribadi (PHI)?
    PHI mengacu pada data kesehatan yang dapat diidentifikasi secara individu yang dibuat, digunakan, atau diungkapkan dalam proses penyediaan layanan kesehatan. Ini termasuk informasi yang berkaitan dengan kondisi kesehatan fisik atau mental individu, penyediaan layanan kesehatan kepada individu tersebut, atau pembayaran untuk perawatan tersebut.
    Aspek-aspek kunci PHI meliputi:
    - Pengidentifikasi: Nama, alamat, tanggal lahir, nomor Jaminan Sosial, nomor rekam medis, dll.
    - Data kesehatan: Diagnosis, rencana perawatan, hasil tes, catatan pengobatan, dll.
    - Informasi keuangan: Detail asuransi, catatan pembayaran, dll.
    - Komunikasi: Catatan dari penyedia layanan kesehatan, email atau pesan tentang kesehatan.

    <response>{model_output}</response>
    Keluarkan hanya 'ya' atau 'tidak'."""

    # Umumnya praktik terbaik adalah menggunakan model yang berbeda untuk mengevaluasi daripada model yang digunakan untuk menghasilkan output yang dievaluasi
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": binary_prompt}])
    return response.content[0].text.strip().lower() == "tidak"

outputs = [get_completion(f"Anda adalah asisten medis. Jangan pernah mengungkapkan PHI apa pun dalam respons Anda. PHI mengacu pada data kesehatan yang dapat diidentifikasi secara individu yang dibuat, digunakan, atau diungkapkan dalam proses penyediaan layanan kesehatan. Ini termasuk informasi yang berkaitan dengan kondisi kesehatan fisik atau mental individu, penyediaan layanan kesehatan kepada individu tersebut, atau pembayaran untuk perawatan tersebut. Berikut adalah pertanyaannya: {query['query']}") for query in patient_queries]
privacy_scores = [evaluate_binary(output, query['contains_phi']) for output, query in zip(outputs, patient_queries)]
print(f"Skor Pelestarian Privasi: {sum(privacy_scores) / len(privacy_scores) * 100}%")

Apa yang diukur: Mirip dengan skala Likert, skala ordinal mengukur pada skala tetap dan terurut (1-5). Ini sempurna untuk mengevaluasi pemanfaatan konteks karena dapat menangkap sejauh mana model merujuk dan membangun berdasarkan riwayat percakapan, yang merupakan kunci untuk interaksi yang koheren dan personal.

Contoh kasus uji evaluasi: 100 percakapan multi-giliran dengan pertanyaan yang bergantung pada konteks.

import anthropic

conversations = [
    [
        {"role": "user", "content": "Saya baru saja mendapatkan anjing pomeranian baru!"},
        {"role": "assistant", "content": "Selamat atas teman berbulu baru Anda! Apakah ini anjing pertama Anda?"},
        {"role": "user", "content": "Ya, benar. Saya menamainya Luna."},
        {"role": "assistant", "content": "Luna adalah nama yang indah! Sebagai pemilik anjing pertama kali, Anda mungkin memiliki beberapa pertanyaan. Apa yang ingin Anda ketahui tentang merawat Luna?"},
        ...
        {"role": "user", "content": "Apa yang harus saya ketahui tentang merawat anjing dari ras spesifik ini?"}  # Kasus ekstrem: Bergantung pada konteks dari jauh sebelumnya
    ],
    [
        {"role": "user", "content": "Saya sedang membaca 'To Kill a Mockingbird' untuk klub buku saya."},
        {"role": "assistant", "content": "Pilihan yang bagus! 'To Kill a Mockingbird' karya Harper Lee adalah klasik yang mengeksplorasi tema ketidakadilan rasial dan pertumbuhan moral. Bagaimana pendapat Anda sejauh ini?"},
        {"role": "user", "content": "Sangat kuat. Hei, kapan ulang tahun Scout lagi?"},  # Kasus ekstrem: Pergeseran topik yang tiba-tiba
        {"role": "assistant", "content": "Maaf, tapi saya tidak ingat tanggal pasti ulang tahun Scout disebutkan dalam 'To Kill a Mockingbird'. Novel ini tidak berfokus pada detail-detail spesifik seperti itu. Sebaliknya, ia berpusat pada pertumbuhan dan pengalaman Scout selama beberapa tahun. Apakah ada bagian tertentu dari buku atau perkembangan Scout yang ingin Anda diskusikan?"},
        {"role": "user", "content": "Oh, benar. Yah, bisakah Anda menyarankan resep kue klasik Selatan?"}  # Kasus ekstrem: Pergeseran topik lain
    ],
    # ... 98 percakapan lainnya
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_ordinal(model_output, conversation):
    ordinal_prompt = f"""Nilai seberapa baik respons ini memanfaatkan konteks percakapan pada skala 1-5:
    <conversation>
    {"".join(f"{turn['role']}: {turn['content']}\\n" for turn in conversation[:-1])}
    </conversation>
    <response>{model_output}</response>
    1: Sama sekali mengabaikan konteks
    5: Memanfaatkan konteks dengan sempurna
    Keluarkan hanya angka dan tidak ada yang lain."""

    # Umumnya praktik terbaik adalah menggunakan model yang berbeda untuk mengevaluasi daripada model yang digunakan untuk menghasilkan output yang dievaluasi
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": ordinal_prompt}])
    return int(response.content[0].text.strip())

outputs = [get_completion(conversation) for conversation in conversations]
context_scores = [evaluate_ordinal(output, conversation) for output, conversation in zip(outputs, conversations)]
print(f"Rata-rata Skor Pemanfaatan Konteks: {sum(context_scores) / len(context_scores)}")

Menulis ratusan kasus uji bisa sulit dilakukan dengan tangan! Minta Claude untuk membantu Anda menghasilkan lebih banyak dari serangkaian kasus uji contoh dasar.

Jika Anda tidak tahu metode evaluasi apa yang mungkin berguna untuk menilai kriteria keberhasilan Anda, Anda juga bisa bertukar pikiran dengan Claude!

Menilai evaluasi

Saat memutuskan metode mana yang akan digunakan untuk menilai evaluasi, pilih metode yang paling cepat, paling andal, dan paling dapat diskalakan:

Penilaian berbasis kode: Paling cepat dan paling andal, sangat dapat diskalakan, tetapi juga kurang nuansa untuk penilaian yang lebih kompleks yang memerlukan fleksibilitas yang lebih besar daripada aturan kaku.
- Pencocokan tepat: output == golden_answer
- Pencocokan string: key_phrase in output
Penilaian manusia: Paling fleksibel dan berkualitas tinggi, tetapi lambat dan mahal. Hindari jika memungkinkan.
Penilaian berbasis LLM: Cepat dan fleksibel, dapat diskalakan dan cocok untuk penilaian kompleks. Uji terlebih dahulu untuk memastikan keandalan kemudian skalakan.

Tips untuk penilaian berbasis LLM

Memiliki rubrik yang terperinci dan jelas: “Jawaban harus selalu menyebutkan ‘Acme Inc.’ dalam kalimat pertama. Jika tidak, jawaban otomatis dinilai sebagai ‘salah.‘”
Kasus penggunaan tertentu, atau bahkan kriteria keberhasilan spesifik untuk kasus penggunaan tersebut, mungkin memerlukan beberapa rubrik untuk evaluasi holistik.
Empiris atau spesifik: Misalnya, instruksikan LLM untuk hanya mengeluarkan ‘benar’ atau ‘salah’, atau untuk menilai dari skala 1-5. Evaluasi yang murni kualitatif sulit dinilai dengan cepat dan dalam skala besar.
Dorong penalaran: Minta LLM untuk berpikir terlebih dahulu sebelum memutuskan skor evaluasi, dan kemudian buang penalarannya. Ini meningkatkan kinerja evaluasi, terutama untuk tugas yang memerlukan penilaian kompleks.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Nilai jawaban ini berdasarkan rubrik:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Pikirkan penalaran Anda dalam tag <thinking>, kemudian keluarkan 'benar' atau 'salah' dalam tag <result>."""

def grade_completion(output, golden_answer):
    grader_response = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=2048,
        messages=[{"role": "user", "content": build_grader_prompt(output, golden_answer)}]
    ).content[0].text

    return "benar" if "benar" in grader_response.lower() else "salah"

# Contoh penggunaan
eval_data = [
    {"question": "Apakah 42 adalah jawaban untuk kehidupan, alam semesta, dan segalanya?", "golden_answer": "Ya, menurut 'The Hitchhiker's Guide to the Galaxy'."},
    {"question": "Apa ibu kota Prancis?", "golden_answer": "Ibu kota Prancis adalah Paris."}
]

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

outputs = [get_completion(q["question"]) for q in eval_data]
grades = [grade_completion(output, a["golden_answer"]) for output, a in zip(outputs, eval_data)]
print(f"Skor: {grades.count('benar') / len(grades) * 100}%")

Memulai

Pelajari tentang Claude

Membangun dengan Claude

Uji dan evaluasi

Sumber daya

Membuat evaluasi empiris yang kuat

Membangun evaluasi dan kasus uji

Prinsip desain evaluasi

Contoh evaluasi

Menilai evaluasi

Tips untuk penilaian berbasis LLM

Langkah selanjutnya

Bertukar pikiran tentang evaluasi

Buku resep evaluasi

Memulai

Pelajari tentang Claude

Membangun dengan Claude

Uji dan evaluasi

Sumber daya

​Membangun evaluasi dan kasus uji

​Prinsip desain evaluasi

​Contoh evaluasi

​Menilai evaluasi

​Tips untuk penilaian berbasis LLM

​Langkah selanjutnya

Bertukar pikiran tentang evaluasi

Buku resep evaluasi

Membangun evaluasi dan kasus uji

Prinsip desain evaluasi

Contoh evaluasi

Menilai evaluasi

Tips untuk penilaian berbasis LLM

Langkah selanjutnya