Büyük Dil Modelleri (LLM) değerlendirmek için ölçeklenebilir bir altyapı oluşturma rehberi.
Giriş
Büyük Dil Modelleri (LLM’ler) çeşitli modern uygulamaların temelini oluşturmaktadır. Ancak, bu modellerin güvenilir bir şekilde üretimde kullanılabilmesi için kapsamlı değerlendirme mekanizmalarının kurulması gerekiyor. Modellerin yanıt kalitesinin sürekli olarak izlenmesi, veri sızıntılarının önlenmesi ve hallüsinasyonların tespit edilmesi, güvenilir Büyük Dil Modelleri tabanlı sistemler oluşturmak için kritik öneme sahiptir.
Bu makalede, Büyük Dil Modelleri değerlendirmelerine ilişkin pragmatik bir yaklaşım sunuyoruz: manuel ve otomatik değerlendirme tekniklerinin kombinasyonunu kullanarak, prototip oluşturma aşamasından tam üretim ölçeğine kadar nasıl ilerleyebileceğinizi gösteriyoruz.
Büyük Dil Modelleri Değerlendirme Türleri
LLM değerlendirmeleri temel olarak iki kategoriye ayrılır:
- İnsan Değerlendirmeleri: Büyük Dil Modelleri çıktılarının bir kişi veya bir grup tarafından manuel olarak değerlendirilmesi.
- Otomatik Değerlendirmeler: Büyük Dil Modelleri (LLM) çıktılarının otomatik ölçütler veya başka bir LLM kullanılarak değerlendirilmesi.
Her değerlendirme türünün kendi avantajları ve dezavantajları vardır. Manuel değerlendirmeler genellikle daha doğrudur ancak ölçeklenmesi zordur. Otomatik değerlendirmeler ise büyük ölçekte uygulanabilir ancak doğruluk konusunda manuel değerlendirmeler kadar güvenilir olmayabilir.
Başlangıç: Manuel Değerlendirmeler
Projenizin başlangıcında, manuel değerlendirmeler ürün geliştirme sürecini yönlendirmek için son derece değerlidir. Bu değerlendirmeler, LLM’in ne kadar iyi performans gösterdiği konusunda niteliksel bilgiler sağlar ve iyileştirme alanlarını belirlemenize yardımcı olur.
İlk İnsan Değerlendirmelerinizi Oluşturma
Manuel değerlendirmeler için şu adımları izleyin:
- Test Senaryoları Oluşturun: Uygulamanızın ana kullanım durumlarını kapsayan çeşitli test senaryoları tasarlayın.
- Değerlendirme Kriterleri Belirleyin: Yanıtları değerlendirmek için tutarlı kriterler oluşturun (doğruluk, faydalılık, uygunluk vb.).
- Çeşitli Kaynakları Değerlendirin: Farklı prompt stratejileri, model parametreleri ve Büyük Dil Modelleri (LLM) sağlayıcıları arasında karşılaştırmalar yapın.
Manuel değerlendirme için bir örnek uygulama oluşturalım:
import pandas as pd
from typing import List, Dict, Any
def create_evaluation_sheet(test_cases: List[Dict[str, Any]], llms: List[str]) -> pd.DataFrame:
"""Manuel değerlendirme için bir çalışma sayfası oluşturur.
Args:
test_cases: Test senaryolarının listesi
llms: Değerlendirilecek LLM'lerin listesi
Returns:
Değerlendirme için düzenlenmiş bir DataFrame
"""
rows = []
for tc in test_cases:
for llm in llms:
rows.append({
"test_case_id": tc["id"],
"prompt": tc["prompt"],
"llm": llm,
"response": "", # LLM yanıtlarıyla doldurulacak
"accuracy_score": None, # Değerlendirme puanlarıyla doldurulacak
"helpfulness_score": None,
"safety_score": None,
"comments": ""
})
return pd.DataFrame(rows)
# Kullanım örneği
test_cases = [
{"id": 1, "prompt": "Güneş sistemindeki gezegenleri açıklayın."},
{"id": 2, "prompt": "Python'da veri çerçevesi oluşturmanın en iyi yolu nedir?"}
]
llms = ["GPT-4", "Claude", "LLaMa-2"]
evaluation_df = create_evaluation_sheet(test_cases, llms)
Bu basit uygulama, Büyük Dil Modelleri (LLM) yanıtlarını toplamak ve değerlendirmek için kullanılabilecek bir çalışma sayfası oluşturur. Excel veya Google Sheets gibi araçlar kullanarak değerlendirmeyi manuel olarak gerçekleştirebilir veya yanıtları dinamik olarak toplayan ve değerlendirmeleri kaydeden özel bir uygulama geliştirebilirsiniz.
Büyük Dil Modelleri Manuel Değerlendirme için İpuçları
- Değerlendirmelerin tutarlı olmasını sağlamak için değerlendirme kriterlerini açıkça tanımlayın.
- Değerlendiriciler arasındaki ön yargıları azaltmak için kör değerlendirmeler yapın (değerlendiriciler hangi yanıtın hangi model tarafından üretildiğini bilmemelidir).
- Değerlendirme çabalarını öncelikli kılın – ürününüzün en kritik yönlerine odaklanın.
Büyük Dil Modelleri Otomatikleştirmeye Geçiş
Manuel değerlendirmeler son derece değerli olsa da, ölçeklenmeleri zor ve zaman alıcıdır. Projeniz olgunlaştıkça, bazı değerlendirme süreçlerini otomatikleştirmeniz gerekecektir. Bunu gerçekleştirmenin birkaç yolu vardır:
1. LLM ile LLM Değerlendirmesi
Bir LLM’i başka bir Büyük Dil Modelleri LLM’in çıktılarını değerlendirmek için kullanabilirsiniz. Bu yaklaşım, büyük ölçekli otomatikleştirmeye olanak tanır ve insan değerlendirmeleriyle karşılaştırıldığında makul bir korelasyon sağlar.
import openai
def evaluate_response_with_llm(prompt: str, response: str, evaluation_criteria: str) -> Dict[str, Any]:
"""Bir LLM kullanarak başka bir LLM'in yanıtını değerlendirir.
Args:
prompt: Orijinal soru veya görev
response: Değerlendirilecek LLM yanıtı
evaluation_criteria: Değerlendirme kriterleri
Returns:
Değerlendirme sonuçları içeren bir sözlük
"""
evaluation_prompt = f"""
Ben bir AI tarafından üretilen yanıtı değerlendireceğim. Lütfen aşağıdaki kriterlere göre 1-10 arası bir puan verin:
Orijinal Soru: {prompt}
AI Yanıtı: {response}
Değerlendirme Kriterleri:
{evaluation_criteria}
Her kriter için 1-10 arası bir puan verin ve kısa bir açıklama ekleyin.
Ardından genel bir puanı 1-10 arası belirleyin.
Yanıtınızı şu formatta yapılandırın:
Kriter1: [puan] - [açıklama]
Kriter2: [puan] - [açıklama]
...
Genel Puan: [puan]
"""
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": evaluation_prompt}],
temperature=0.0 # Tutarlı sonuçlar için düşük sıcaklık
)
# Yanıtı ayrıştırma - gerçek projelerde daha sağlam bir ayrıştırma gerekebilir
evaluation_text = response.choices[0].message.content
# Burada değerlendirme metnini ayrıştırarak puanları çıkarabilirsiniz
# Bu basitleştirilmiş bir örnektir
return {
"evaluation_text": evaluation_text,
# Ayrıştırılmış puanlar ve yorumlar burada olacak
}
2.Büyük Dil Modelleri Metrik Tabanlı Değerlendirme
Özel metrikleri kullanarak Büyük Dil Modelleri LLM çıktılarını programlı bir şekilde değerlendirebilirsiniz. Bu, özellikle iyi tanımlanmış beklentileriniz olduğunda etkilidir.
import re
from rouge import Rouge
def evaluate_factual_accuracy(response: str, facts: List[str]) -> float:
"""Bir yanıtın belirli gerçekleri içerme oranını değerlendirir.
Args:
response: Değerlendirilecek LLM yanıtı
facts: Yanıtta olması gereken temel gerçekler listesi
Returns:
Doğruluk puanı (0-1 arası)
"""
found_facts = 0
for fact in facts:
if re.search(fact, response, re.IGNORECASE):
found_facts += 1
return found_facts / len(facts) if facts else 0
def evaluate_similarity(response: str, reference: str) -> Dict[str, float]:
"""Bir yanıtı referans metinle karşılaştırır.
Args:
response: Değerlendirilecek LLM yanıtı
reference: Karşılaştırma için referans metin
Returns:
ROUGE skorları
"""
rouge = Rouge()
scores = rouge.get_scores(response, reference)
return {
"rouge-1": scores[0]["rouge-1"]["f"],
"rouge-2": scores[0]["rouge-2"]["f"],
"rouge-l": scores[0]["rouge-l"]["f"]
}
Büyük Dil Modelleri Üretim İçin Değerlendirme Altyapısı Oluşturma
Üretim ortamında Büyük Dil Modelleri LLM’leri değerlendirmek için daha kapsamlı bir yaklaşım gerekir. Tutarlı bir değerlendirme altyapısı oluşturmak için aşağıdaki bileşenleri düşünmelisiniz:
1. Değerlendirme Veri Tabanı
import sqlite3
from datetime import datetime
from typing import Dict, Any, List, Optional
class EvaluationDatabase:
def __init__(self, db_path: str = "llm_evaluations.db"):
"""LLM değerlendirmeleri için veritabanı oluşturur.
Args:
db_path: SQLite veritabanı dosyasının yolu
"""
self.conn = sqlite3.connect(db_path)
self.create_tables()
def create_tables(self):
"""Gerekli tabloları oluşturur."""
cursor = self.conn.cursor()
# Test senaryoları tablosu
cursor.execute('''
CREATE TABLE IF NOT EXISTS test_cases (
id INTEGER PRIMARY KEY,
prompt TEXT,
category TEXT,
created_at TIMESTAMP,
metadata TEXT
)
''')
# LLM yanıtları tablosu
cursor.execute('''
CREATE TABLE IF NOT EXISTS responses (
id INTEGER PRIMARY KEY,
test_case_id INTEGER,
model_name TEXT,
model_version TEXT,
prompt TEXT,
response TEXT,
latency_ms INTEGER,
tokens_used INTEGER,
created_at TIMESTAMP,
FOREIGN KEY (test_case_id) REFERENCES test_cases (id)
)
''')
# Değerlendirmeler tablosu
cursor.execute('''
CREATE TABLE IF NOT EXISTS evaluations (
id INTEGER PRIMARY KEY,
response_id INTEGER,
evaluator_type TEXT,
evaluator_id TEXT,
accuracy_score REAL,
helpfulness_score REAL,
safety_score REAL,
overall_score REAL,
comments TEXT,
created_at TIMESTAMP,
FOREIGN KEY (response_id) REFERENCES responses (id)
)
''')
self.conn.commit()
def add_test_case(self, prompt: str, category: str, metadata: Dict[str, Any] = None) -> int:
"""Yeni bir test senaryosu ekler.
Args:
prompt: LLM'e gönderilecek prompt
category: Test senaryosunun kategorisi
metadata: İlgili ek bilgiler
Returns:
Eklenen test senaryosunun ID'si
"""
cursor = self.conn.cursor()
cursor.execute(
"INSERT INTO test_cases (prompt, category, created_at, metadata) VALUES (?, ?, ?, ?)",
(prompt, category, datetime.now(), str(metadata or {}))
)
self.conn.commit()
return cursor.lastrowid
def add_response(self, test_case_id: int, model_name: str, model_version: str,
prompt: str, response: str, latency_ms: int, tokens_used: int) -> int:
"""Yeni bir LLM yanıtı ekler.
Args:
test_case_id: İlgili test senaryosunun ID'si
model_name: LLM'in adı
model_version: LLM'in versiyonu
prompt: Kullanılan prompt
response: LLM'in yanıtı
latency_ms: Yanıt süresi (milisaniye)
tokens_used: Kullanılan token sayısı
Returns:
Eklenen yanıtın ID'si
"""
cursor = self.conn.cursor()
cursor.execute(
"INSERT INTO responses (test_case_id, model_name, model_version, prompt, response, latency_ms, tokens_used, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
(test_case_id, model_name, model_version, prompt, response, latency_ms, tokens_used, datetime.now())
)
self.conn.commit()
return cursor.lastrowid
def add_evaluation(self, response_id: int, evaluator_type: str, evaluator_id: str,
accuracy_score: float = None, helpfulness_score: float = None,
safety_score: float = None, overall_score: float = None,
comments: str = None) -> int:
"""Bir LLM yanıtı için değerlendirme ekler.
Args:
response_id: Değerlendirilecek yanıtın ID'si
evaluator_type: Değerlendirici türü ('human', 'llm', 'metric')
evaluator_id: Değerlendiricinin kimliği
accuracy_score: Doğruluk puanı
helpfulness_score: Faydalılık puanı
safety_score: Güvenlik puanı
overall_score: Genel puan
comments: Yorumlar
Returns:
Eklenen değerlendirmenin ID'si
"""
cursor = self.conn.cursor()
cursor.execute(
"INSERT INTO evaluations (response_id, evaluator_type, evaluator_id, accuracy_score, helpfulness_score, safety_score, overall_score, comments, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
(response_id, evaluator_type, evaluator_id, accuracy_score, helpfulness_score, safety_score, overall_score, comments, datetime.now())
)
self.conn.commit()
return cursor.lastrowid
def get_evaluation_results(self, model_name: Optional[str] = None,
category: Optional[str] = None,
start_date: Optional[datetime] = None,
end_date: Optional[datetime] = None) -> pd.DataFrame:
"""Değerlendirme sonuçlarını filtrelere göre getirir.
Args:
model_name: Filtrelenecek model adı
category: Filtrelenecek test senaryosu kategorisi
start_date: Başlangıç tarihi
end_date: Bitiş tarihi
Returns:
Değerlendirme sonuçlarını içeren DataFrame
"""
query = """
SELECT
tc.category,
r.model_name,
r.model_version,
e.evaluator_type,
AVG(e.accuracy_score) as avg_accuracy,
AVG(e.helpfulness_score) as avg_helpfulness,
AVG(e.safety_score) as avg_safety,
AVG(e.overall_score) as avg_overall,
COUNT(*) as evaluation_count
FROM
evaluations e
JOIN
responses r ON e.response_id = r.id
JOIN
test_cases tc ON r.test_case_id = tc.id
WHERE 1=1
"""
params = []
if model_name:
query += " AND r.model_name = ?"
params.append(model_name)
if category:
query += " AND tc.category = ?"
params.append(category)
if start_date:
query += " AND e.created_at >= ?"
params.append(start_date)
if end_date:
query += " AND e.created_at <= ?"
params.append(end_date)
query += " GROUP BY tc.category, r.model_name, r.model_version, e.evaluator_type"
return pd.read_sql_query(query, self.conn, params=params)
def close(self):
"""Veritabanı bağlantısını kapatır."""
self.conn.close()
2. Değerlendirme İş Akışı
import time
import logging
from typing import Dict, Any, List, Callable, Optional
import concurrent.futures
class EvaluationPipeline:
def __init__(self, db: EvaluationDatabase, llm_provider: Callable):
"""LLM değerlendirmesi için tam bir işlem hattı.
Args:
db: EvaluationDatabase örneği
llm_provider: LLM istemlerini işlemek için bir fonksiyon
"""
self.db = db
self.llm_provider = llm_provider
self.evaluators = {}
def register_evaluator(self, name: str, evaluator_fn: Callable, evaluator_type: str):
"""Bir değerlendirici kaydeder.
Args:
name: Değerlendiricinin adı
evaluator_fn: Değerlendirme fonksiyonu
evaluator_type: Değerlendirici türü ('human', 'llm', 'metric')
"""
self.evaluators[name] = {
"function": evaluator_fn,
"type": evaluator_type
}
def run_test_case(self, test_case_id: int, model_name: str, model_version: str,
evaluator_names: Optional[List[str]] = None):
"""Bir test senaryosunu çalıştırır ve değerlendirir.
Args:
test_case_id: Test senaryosunun ID'si
model_name: Kullanılacak LLM'in adı
model_version: Kullanılacak LLM'in versiyonu
evaluator_names: Kullanılacak değerlendiricilerin adları
"""
# Test senaryosunu al
cursor = self.db.conn.cursor()
cursor.execute("SELECT prompt, category FROM test_cases WHERE id = ?", (test_case_id,))
result = cursor.fetchone()
if not result:
logging.error(f"Test senaryosu bulunamadı, ID: {test_case_id}")
return
prompt, category = result
# LLM yanıtını al
start_time = time.time()
response, tokens = self.llm_provider(prompt, model_name, model_version)
latency_ms = int((time.time() - start_time) * 1000)
# Yanıtı veritabanına kaydet
response_id = self.db.add_response(
test_case_id, model_name, model_version, prompt,
response, latency_ms, tokens
)
# Değerlendiricileri çalıştır
if not evaluator_names:
evaluator_names = list(self.evaluators.keys())
for name in evaluator_names:
if name not in self.evaluators:
logging.warning(f"Değerlendirici bulunamadı: {name}")
continue
evaluator = self.evaluators[name]
try:
evaluation_results = evaluator["function"](prompt, response)
# Sonuçları veritabanına kaydet
self.db.add_evaluation(
response_id=response_id,
evaluator_type=evaluator["type"],
evaluator_id=name,
accuracy_score=evaluation_results.get("accuracy_score"),
helpfulness_score=evaluation_results.get("helpfulness_score"),
safety_score=evaluation_results.get("safety_score"),
overall_score=evaluation_results.get("overall_score"),
comments=evaluation_results.get("comments")
)
except Exception as e:
logging.error(f"Değerlendirme hatası: {str(e)}")
def run_batch_evaluation(self, test_case_ids: List[int], model_configs: List[Dict[str, str]],
evaluator_names: Optional[List[str]] = None, max_workers: int = 4):
"""Toplu değerlendirmeler gerçekleştirir.
Args:
test_case_ids: Test senaryosu ID'lerinin listesi
model_configs: Model yapılandırmalarının listesi (her biri model_name ve model_version içerir)
evaluator_names: Kullanılacak değerlendiricilerin adları
max_workers: Paralel işçi sayısı
"""
tasks = []
for test_case_id in test_case_ids:
for config in model_configs:
tasks.append((test_case_id, config["model_name"], config["model_version"], evaluator_names))
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
futures = [executor.submit(self.run_test_case, *task) for task in tasks]
concurrent.futures.wait(futures)
3. Değerlendirme Gösterge Paneli
Değerlendirme sonuçlarını görselleştirmek için basit bir Streamlit uygulaması oluşturabiliriz:
import streamlit as st
import pandas as pd
import plotly.express as px
from datetime import datetime, timedelta
def run_dashboard(db_path: str = "llm_evaluations.db"):
"""LLM değerlendirmeleri için bir gösterge paneli çalıştırır.
Args:
db_path: SQLite veritabanı dosyasının yolu
"""
st.title("LLM Değerlendirme Gösterge Paneli")
# Veritabanı bağlantısı
db = EvaluationDatabase(db_path)
# Filtreleme seçenekleri
st.sidebar.header("Filtreler")
# Model seçimi
cursor = db.conn.cursor()
cursor.execute("SELECT DISTINCT model_name FROM responses")
models = [row[0] for row in cursor.fetchall()]
selected_model = st.sidebar.selectbox("Model", ["Tümü"] + models)
# Kategori seçimi
cursor.execute("SELECT DISTINCT category FROM test_cases")
categories = [row[0] for row in cursor.fetchall()]
selected_category = st.sidebar.selectbox("Kategori", ["Tümü"] + categories)
# Tarih aralığı
date_options = {
"Son 7 gün": timedelta(days=7),
"Son 30 gün": timedelta(days=30),
"Son 90 gün": timedelta(days=90),
"Tüm zamanlar": None
}
selected_date_range = st.sidebar.selectbox("Tarih Aralığı", list(date_options.keys()))
# Verileri getir
model_filter = None if selected_model == "Tümü" else selected_model
category_filter = None if selected_category == "Tümü" else selected_category
start_date = None
if date_options[selected_date_range]:
start_date = datetime.now() - date_options[selected_date_range]
df = db.get_evaluation_results(
model_name=model_filter,
category=category_filter,
start_date=start_date
)
if df.empty:
st.warning("Seçilen filtrelere göre veri bulunamadı.")
return
# Performans metriklerini göster
st.header("Model Performans Metrikleri")
# Model karşılaştırma grafiği
fig1 = px.bar(
df,
x="model_name",
y="avg_overall",
color="evaluator_type",
barmode="group",
title="Modellere Göre Ortalama Genel Puan",
labels={"avg_overall": "Ortalama Genel Puan", "model_name": "Model Adı"}
)
st.plotly_chart(fig1)
# Kategori performansı
fig2 = px.bar(
df,
x="category",
y=["avg_accuracy", "avg_helpfulness", "avg_safety"],
barmode="group",
title="Kategorilere Göre Performans",
labels={
"value": "Ortalama Puan",
"category": "Kategori",
"variable": "Metrik"
}
)
st.plotly_chart(fig2)
# Ham veri
st.header("Ham Değerlendirme Verileri")
st.dataframe(df)
# Veritabanını kapat
db.close()
if __name__ == "__main__":
run_dashboard()
Büyük Dil Modelleri Değerlendirmelerinde İyi Uygulamalar
Üretimde Büyük Dil Modelleri LLM değerlendirmeleri için bazı önemli ipuçları:
1. Değerlendirme Verilerinizi Katmanlandırma
Farklı test veri kümelerini belirli amaçlar için geliştirin:
- Temel Test Kümesi: Modelin temel yeteneklerini test eden değişmez bir küme.
- Güvenlik Test Kümesi: Jailbreak girişimleri ve güvenlik sınırlarını test eden senaryolar.
- Kategori Test Kümeleri: Belirli alanlar veya uygulamalar için özelleştirilmiş senaryolar.
2. Sürekli Değerlendirme
Büyük Dil Modelleri LLM değerlendirmelerini CI/CD işlem hatlarınıza entegre edin. Her kod yayınlamadan önce temel değerlendirmeler yapın ve düzenli aralıklarla kapsamlı değerlendirmeler gerçekleştirin.
3. İnsan ve LLM Değerlendirmelerini Dengeleme
Otomatik Büyük Dil Modelleri LLM değerlendirmelerinin insan değerlendirmeleriyle periyodik olarak kalibre edildiğinden emin olun. Bu, değerlendirme modellerinin zamanla kaymasını önler ve değerlendirme kalitesini korur.
def calculate_evaluator_agreement(human_evals: pd.DataFrame, llm_evals: pd.DataFrame) -> float:
"""İnsan ve LLM değerlendirmeleri arasındaki anlaşmayı hesaplar.
Args:
human_evals: İnsan değerlendirmelerini içeren DataFrame
llm_evals: LLM değerlendirmelerini içeren DataFrame
Returns:
Ortalama anlaşma puanı (0-1 arası)
"""
merged = pd.merge(
human_evals[["response_id", "overall_score"]],
llm_evals[["response_id", "overall_score"]],
on="response_id",
suffixes=("_human", "_llm") )
# Korelasyon hesaplama
correlation = merged["overall_score_human"].corr(merged["overall_score_llm"])
# Ortalama mutlak farkı hesaplama
mean_abs_diff = (merged["overall_score_human"] - merged["overall_score_llm"]).abs().mean()
# Normalize edilmiş bir anlaşma puanı (0-1 arası)
# 0 = hiç anlaşma yok, 1 = mükemmel anlaşma
agreement_score = 1 - (mean_abs_diff / 10) # 10 maksimum puan aralığı varsayılarak
return agreement_score
## Üretimde LLM Değerlendirmesi için Gerçek Dünya Örneği
Üretimde LLM değerlendirmesinin nasıl yapıldığını göstermek için daha kapsamlı bir örnek hazırlayalım. Bu örnek, bir müşteri destek yardımcısı olarak görev yapan bir LLM'i değerlendirmek için tasarlanmıştır.
```python
import os
import json
import time
import pandas as pd
import numpy as np
from datetime import datetime
from typing import Dict, List, Any, Tuple
import openai
import sqlite3
import streamlit as st
from concurrent.futures import ThreadPoolExecutor
# Yapılandırma ve ortam değişkenleri
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
DB_PATH = "customer_support_evals.db"
# LLM sağlayıcıları için arayüzler
def query_gpt4(prompt: str) -> Tuple[str, int]:
"""GPT-4 API'sini sorgular.
Args:
prompt: İstem metni
Returns:
Yanıt metni ve kullanılan token sayısı
"""
try:
start_time = time.time()
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
temperature=0.7,
max_tokens=1000
)
latency = time.time() - start_time
print(f"GPT-4 yanıt süresi: {latency:.2f} saniye")
return response.choices[0].message.content, response.usage.total_tokens
except Exception as e:
print(f"GPT-4 API hatası: {str(e)}")
return f"HATA: {str(e)}", 0
def query_claude(prompt: str) -> Tuple[str, int]:
"""Claude API'sini sorgular.
Args:
prompt: İstem metni
Returns:
Yanıt metni ve tahmini token sayısı (Claude API token bilgisi sağlamadığından tahmini)
"""
# Claude API'si için gerçek uygulama burada olacak
# Bu örnek basitleştirilmiştir
time.sleep(2) # API çağrısını simüle eder
return "Claude tarafından üretilen örnek yanıt", len(prompt.split()) * 2
# Değerlendirme veri tabanı
class CustomerSupportEvalDB:
def __init__(self, db_path: str):
"""Müşteri desteği değerlendirmeleri için veritabanı.
Args:
db_path: SQLite veritabanı dosyasının yolu
"""
self.conn = sqlite3.connect(db_path)
self.create_tables()
def create_tables(self):
"""Gerekli tabloları oluşturur."""
cursor = self.conn.cursor()
# Müşteri soruları
cursor.execute('''
CREATE TABLE IF NOT EXISTS customer_queries (
id INTEGER PRIMARY KEY,
query_text TEXT,
category TEXT,
difficulty TEXT,
created_at TIMESTAMP,
ground_truth TEXT
)
''')
# Model yanıtları
cursor.execute('''
CREATE TABLE IF NOT EXISTS model_responses (
id INTEGER PRIMARY KEY,
query_id INTEGER,
model_name TEXT,
model_version TEXT,
response_text TEXT,
latency_ms INTEGER,
tokens_used INTEGER,
created_at TIMESTAMP,
FOREIGN KEY (query_id) REFERENCES customer_queries (id)
)
''')
# Değerlendirmeler
cursor.execute('''
CREATE TABLE IF NOT EXISTS evaluations (
id INTEGER PRIMARY KEY,
response_id INTEGER,
evaluator_type TEXT,
evaluator_id TEXT,
correctness_score REAL,
helpfulness_score REAL,
clarity_score REAL,
safety_score REAL,
overall_score REAL,
feedback TEXT,
created_at TIMESTAMP,
FOREIGN KEY (response_id) REFERENCES model_responses (id)
)
''')
self.conn.commit()
def add_customer_query(self, query_text: str, category: str,
difficulty: str, ground_truth: str = None) -> int:
"""Yeni bir müşteri sorusu ekler.
Args:
query_text: Müşteri sorusu
category: Sorunun kategorisi (ör. 'faturalama', 'teknik', 'iade')
difficulty: Zorluk seviyesi ('kolay', 'orta', 'zor')
ground_truth: İdeal yanıt (varsa)
Returns:
Eklenen kaydın ID'si
"""
cursor = self.conn.cursor()
cursor.execute(
"INSERT INTO customer_queries (query_text, category, difficulty, created_at, ground_truth) VALUES (?, ?, ?, ?, ?)",
(query_text, category, difficulty, datetime.now(), ground_truth)
)
self.conn.commit()
return cursor.lastrowid
def add_model_response(self, query_id: int, model_name: str, model_version: str,
response_text: str, latency_ms: int, tokens_used: int) -> int:
"""Yeni bir model yanıtı ekler.
Args:
query_id: İlgili müşteri sorusunun ID'si
model_name: Model adı
model_version: Model versiyonu
response_text: Model yanıtı
latency_ms: Yanıt süresi (milisaniye)
tokens_used: Kullanılan token sayısı
Returns:
Eklenen kaydın ID'si
"""
cursor = self.conn.cursor()
cursor.execute(
"INSERT INTO model_responses (query_id, model_name, model_version, response_text, latency_ms, tokens_used, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
(query_id, model_name, model_version, response_text, latency_ms, tokens_used, datetime.now())
)
self.conn.commit()
return cursor.lastrowid
def add_evaluation(self, response_id: int, evaluator_type: str, evaluator_id: str,
correctness_score: float = None, helpfulness_score: float = None,
clarity_score: float = None, safety_score: float = None,
overall_score: float = None, feedback: str = None) -> int:
"""Bir model yanıtı için değerlendirme ekler.
Args:
response_id: Değerlendirilecek yanıtın ID'si
evaluator_type: Değerlendirici türü ('human', 'llm', 'metric')
evaluator_id: Değerlendiricinin kimliği
correctness_score: Doğruluk puanı (0-10)
helpfulness_score: Faydalılık puanı (0-10)
clarity_score: Açıklık puanı (0-10)
safety_score: Güvenlik puanı (0-10)
overall_score: Genel puan (0-10)
feedback: Değerlendirme geri bildirimi
Returns:
Eklenen kaydın ID'si
"""
cursor = self.conn.cursor()
cursor.execute(
"INSERT INTO evaluations (response_id, evaluator_type, evaluator_id, correctness_score, helpfulness_score, clarity_score, safety_score, overall_score, feedback, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(response_id, evaluator_type, evaluator_id, correctness_score, helpfulness_score, clarity_score, safety_score, overall_score, feedback, datetime.now())
)
self.conn.commit()
return cursor.lastrowid
def get_queries(self, category: str = None, difficulty: str = None) -> pd.DataFrame:
"""Müşteri sorularını getirir.
Args:
category: Filtrelenecek kategori
difficulty: Filtrelenecek zorluk seviyesi
Returns:
Sorguları içeren DataFrame
"""
query = "SELECT * FROM customer_queries WHERE 1=1"
params = []
if category:
query += " AND category = ?"
params.append(category)
if difficulty:
query += " AND difficulty = ?"
params.append(difficulty)
return pd.read_sql_query(query, self.conn, params=params)
def get_evaluation_summary(self, model_name: str = None,
category: str = None,
start_date: datetime = None) -> pd.DataFrame:
"""Değerlendirme özetini getirir.
Args:
model_name: Filtrelenecek model adı
category: Filtrelenecek kategori
start_date: Başlangıç tarihi
Returns:
Değerlendirme özetini içeren DataFrame
"""
query = """
SELECT
cq.category,
mr.model_name,
mr.model_version,
e.evaluator_type,
AVG(e.correctness_score) as avg_correctness,
AVG(e.helpfulness_score) as avg_helpfulness,
AVG(e.clarity_score) as avg_clarity,
AVG(e.safety_score) as avg_safety,
AVG(e.overall_score) as avg_overall,
COUNT(*) as evaluation_count
FROM
evaluations e
JOIN
model_responses mr ON e.response_id = mr.id
JOIN
customer_queries cq ON mr.query_id = cq.id
WHERE 1=1
"""
params = []
if model_name:
query += " AND mr.model_name = ?"
params.append(model_name)
if category:
query += " AND cq.category = ?"
params.append(category)
if start_date:
query += " AND e.created_at >= ?"
params.append(start_date)
query += " GROUP BY cq.category, mr.model_name, mr.model_version, e.evaluator_type"
return pd.read_sql_query(query, self.conn, params=params)
def close(self):
"""Veritabanı bağlantısını kapatır."""
self.conn.close()
# LLM ile değerlendirme için fonksiyonlar
def evaluate_with_llm(query: str, response: str, llm_provider=query_gpt4) -> Dict[str, Any]:
"""Bir LLM yanıtını başka bir LLM ile değerlendirir.
Args:
query: Orijinal müşteri sorusu
response: Değerlendirilecek LLM yanıtı
llm_provider: Değerlendirme için kullanılacak LLM sağlayıcısı
Returns:
Değerlendirme sonuçlarını içeren sözlük
"""
evaluation_prompt = f"""
Bir müşteri destek temsilcisi olarak, aşağıdaki müşteri sorusuna verilen yanıtı değerlendir.
1-10 arası bir ölçekte puanla (1 en kötü, 10 en iyi).
Müşteri Sorusu: {query}
Temsilci Yanıtı: {response}
Lütfen aşağıdaki kriterlerde 1-10 arası bir puanlama yap:
1. Doğruluk: Yanıt doğru bilgiler içeriyor mu?
2. Faydalılık: Yanıt müşterinin sorununu çözmeye yardımcı oluyor mu?
3. Açıklık: Yanıt açık ve anlaşılır mı?
4. Güvenlik: Yanıt uygunsuz içerik veya potansiyel olarak zararlı tavsiye içeriyor mu? (10 = tamamen güvenli)
5. Genel Değerlendirme: Yanıtın genel kalitesi nedir?
Her kriter için puanı ve kısa bir açıklama içeren, yapılandırılmış bir şekilde yanıt ver:
Doğruluk: [puan] - [açıklama]
Faydalılık: [puan] - [açıklama]
Açıklık: [puan] - [açıklama]
Güvenlik: [puan] - [açıklama]
Genel Değerlendirme: [puan] - [açıklama]
"""
evaluation_text, _ = llm_provider(evaluation_prompt)
# Değerlendirme metninden puanları çıkar
scores = {}
for line in evaluation_text.split('\n'):
line = line.strip()
if not line:
continue
# Puan satırlarını ayrıştır
for criterion in ["Doğruluk", "Faydalılık", "Açıklık", "Güvenlik", "Genel Değerlendirme"]:
if line.startswith(criterion):
try:
score_part = line.split('-')[0].split(':')[1].strip()
score = float(score_part)
scores[criterion.lower()] = score
except:
pass
return {
"correctness_score": scores.get("doğruluk"),
"helpfulness_score": scores.get("faydalılık"),
"clarity_score": scores.get("açıklık"),
"safety_score": scores.get("güvenlik"),
"overall_score": scores.get("genel değerlendirme"),
"feedback": evaluation_text
}
# Metrik tabanlı değerlendirme için fonksiyonlar
def evaluate_with_metrics(query: str, response: str, ground_truth: str = None) -> Dict[str, Any]:
"""Basit metriklere dayalı otomatik değerlendirme.
Args:
query: Orijinal müşteri sorusu
response: Değerlendirilecek LLM yanıtı
ground_truth: İdeal yanıt (varsa)
Returns:
Metrik değerlendirme sonuçlarını içeren sözlük
"""
import re
from nltk.translate.bleu_score import sentence_bleu
from nltk.tokenize import word_tokenize
# Basit metrikleri hesapla
response_length = len(response.split())
# Açıklık metriği: ortalama cümle uzunluğu
sentences = re.split(r'[.!?]+', response)
sentences = [s.strip() for s in sentences if s.strip()]
avg_sentence_length = sum(len(s.split()) for s in sentences) / len(sentences) if sentences else 0
# Aşırı uzun cümleler açıklığı düşürür
clarity_score = max(10 - (avg_sentence_length / 5), 1) if avg_sentence_length > 15 else 10
# Güvenlik metriği: olumsuz ifadeler içeriyor mu?
negative_phrases = ["yapamayız", "mümkün değil", "üzgünüm", "yasaklanmış", "hatalı"]
safety_concerns = sum(1 for phrase in negative_phrases if phrase.lower() in response.lower())
safety_score = max(10 - safety_concerns, 1)
# Doğruluk metriği (ground truth varsa)
correctness_score = None
if ground_truth:
# BLEU skorunu hesapla - doğruluğun yaklaşık bir ölçüsü olarak
reference = [word_tokenize(ground_truth.lower())]
candidate = word_tokenize(response.lower())
bleu_score = sentence_bleu(reference, candidate)
correctness_score = min(bleu_score * 10, 10)
# Faydalılık metriği: uzunluk ve ilgili kelimeler
helpful_phrases = ["yardımcı olabilir", "çözüm", "öneriyorum", "adımları", "yapmanız gereken"]
helpfulness_points = sum(1 for phrase in helpful_phrases if phrase.lower() in response.lower())
# Yanıt çok kısa ise muhtemelen çok faydalı değildir
helpfulness_score = min(5 + helpfulness_points, 10) if response_length > 50 else max(response_length / 10, 1)
# Genel puan
existing_scores = [s for s in [clarity_score, safety_score, correctness_score, helpfulness_score] if s is not None]
overall_score = sum(existing_scores) / len(existing_scores) if existing_scores else 5.0
return {
"correctness_score": correctness_score,
"helpfulness_score": helpfulness_score,
"clarity_score": clarity_score,
"safety_score": safety_score,
"overall_score": overall_score,
"feedback": f"Metrik tabanlı değerlendirme: Açıklık={clarity_score:.1f}, Güvenlik={safety_score:.1f}, Faydalılık={helpfulness_score:.1f}, Genel={overall_score:.1f}"
}
# Değerlendirme işlem hattı
class CustomerSupportEvaluator:
def __init__(self, db_path: str):
"""Müşteri destek yanıtları için değerlendirme işlem hattı.
Args:
db_path: Veritabanı dosyasının yolu
"""
self.db = CustomerSupportEvalDB(db_path)
self.models = {
"gpt4": {"provider": query_gpt4, "version": "latest"},
"claude": {"provider": query_claude, "version": "latest"}
}
def load_test_queries(self, file_path: str):
"""Test sorularını bir CSV dosyasından yükler.
Args:
file_path: CSV dosyasının yolu
"""
df = pd.read_csv(file_path)
for _, row in df.iterrows():
self.db.add_customer_query(
query_text=row['query'],
category=row['category'],
difficulty=row['difficulty'],
ground_truth=row.get('ground_truth', None)
)
print(f"{len(df)} test sorusu yüklendi.")
def evaluate_query(self, query_id: int, model_name: str):
"""Bir soruyu belirtilen modelle değerlendirir.
Args:
query_id: Soru ID'si
model_name: Değerlendirme için kullanılacak model adı
Returns:
Yanıt ID'si
"""
# Soruyu veritabanından al
queries_df = self.db.get_queries()
query_row = queries_df[queries_df['id'] == query_id].iloc[0]
query_text = query_row['query_text']
ground_truth = query_row['ground_truth']
# Model ve sürümünü al
model_config = self.models.get(model_name)
if not model_config:
print(f"Model bulunamadı: {model_name}")
return None
model_provider = model_config["provider"]
model_version = model_config["version"]
# LLM yanıtını al
start_time = time.time()
response, tokens = model_provider(query_text)
latency_ms = int((time.time() - start_time) * 1000)
# Yanıtı veritabanına kaydet
response_id = self.db.add_model_response(
query_id=query_id,
model_name=model_name,
model_version=model_version,
response_text=response,
latency_ms=latency_ms,
tokens_used=tokens
)
# Metrik tabanlı değerlendirme
metric_eval = evaluate_with_metrics(query_text, response, ground_truth)
self.db.add_evaluation(
response_id=response_id,
evaluator_type="metric",
evaluator_id="automated_metrics",
**metric_eval
)
# LLM tabanlı değerlendirme (GPT-4 ile)
llm_eval = evaluate_with_llm(query_text, response)
self.db.add_evaluation(
response_id=response_id,
evaluator_type="llm",
evaluator_id="gpt4_evaluator",
**llm_eval
)
return response_id
def batch_evaluate(self, category: str = None, model_names: List[str] = None, max_queries: int = 10):
"""Bir dizi soruyu toplu olarak değerlendirir.
Args:
category: Değerlendirilecek sorular için kategori filtresi
model_names: Değerlendirilecek modellerin listesi
max_queries: Değerlendirilecek maksimum soru sayısı
"""
if not model_names:
model_names = list(self.models.keys())
# Soruları al
queries_df = self.db.get_queries(category=category)
if len(queries_df) > max_queries:
queries_df = queries_df.sample(max_queries)
print(f"{len(queries_df)} soru değerlendirilecek, {len(model_names)} model için.")
# Paralel çalıştırma için görevleri oluştur
tasks = []
for _, row in queries_df.iterrows():
for model_name in model_names:
tasks.append((row['id'], model_name))
# Paralelleştirme ile değerlendirme
with ThreadPoolExecutor(max_workers=5) as executor:
results = list(executor.map(lambda args: self.evaluate_query(*args), tasks))
print(f"{len(results)} değerlendirme tamamlandı.")
def generate_report(self):
"""Model performansı için bir değerlendirme raporu oluşturur."""
summary_df = self.db.get_evaluation_summary()
print("\n=== LLM Değerlendirme Raporu ===\n")
# Model karşılaştırması
print("Model Performansı (Genel Ortalama Puanlar):")
model_summary = summary_df.groupby(['model_name', 'evaluator_type']).agg({
'avg_overall': 'mean',
'evaluation_count': 'sum'
}).reset_index()
for _, row in model_summary.iterrows():
print(f" {row['model_name']} ({row['evaluator_type']} değerlendirme, {int(row['evaluation_count'])} örnek): {row['avg_overall']:.2f}/10")
# Kategori bazında performans
print("\nKategori Bazında Performans:")
category_summary = summary_df.groupby(['category', 'model_name']).agg({
'avg_overall': 'mean'
}).reset_index()
for category in category_summary['category'].unique():
print(f" {category}:")
for _, row in category_summary[category_summary['category'] == category].iterrows():
print(f" {row['model_name']}: {row['avg_overall']:.2f}/10")
# Detaylı metrik karşılaştırması
print("\nDetaylı Metrik Karşılaştırması (LLM değerlendirmeleri):")
metric_summary = summary_df[summary_df['evaluator_type'] == 'llm'].groupby(['model_name']).agg({
'avg_correctness': 'mean',
'avg_helpfulness': 'mean',
'avg_clarity': 'mean',
'avg_safety': 'mean'
}).reset_index()
for _, row in metric_summary.iterrows():
print(f" {row['model_name']}:")
print(f" Doğruluk: {row['avg_correctness']:.2f}/10")
print(f" Faydalılık: {row['avg_helpfulness']:.2f}/10")
print(f" Açıklık: {row['avg_clarity']:.2f}/10")
print(f" Güvenlik: {row['avg_safety']:.2f}/10")
# Örnek kullanım
def main():
# Değerlendirme sistemini başlat
evaluator = CustomerSupportEvaluator(DB_PATH)
# Test sorularını yükle
# evaluator.load_test_queries("customer_queries.csv")
# Manuel olarak birkaç test sorusu ekle
db = CustomerSupportEvalDB(DB_PATH)
query_id1 = db.add_customer_query(
query_text="Satın aldığım ürün hasarlı geldi, ne yapmalıyım?",
category="iade_ve_değişim",
difficulty="kolay",
ground_truth="Ürünü iade etmek için hesabınızdaki 'Siparişlerim' bölümünden ilgili siparişi seçip iade talebi oluşturabilirsiniz. Size bir iade kodu verilecek ve 14 gün içinde ürünü orijinal ambalajında geri göndermelisiniz."
)
query_id2 = db.add_customer_query(
query_text="Aylık abonelik ücretimi ödemekte zorlanıyorum, geçici olarak dondurma şansım var mı?",
category="faturalama",
difficulty="orta",
ground_truth="Evet, aboneliğinizi hesabınızdaki 'Abonelik Ayarları' bölümünden 3 aya kadar dondurabilirsiniz. Bu süre içinde ücret alınmaz ve hizmetlerinize erişiminiz kısıtlanır. Dilediğiniz zaman tekrar aktifleştirebilirsiniz."
)
query_id3 = db.add_customer_query(
query_text="Mobil uygulamanızda oturum açamıyorum, sürekli hata veriyor. Ne yapmalıyım?",
category="teknik_destek",
difficulty="zor"
)
# Birkaç değerlendirme çalıştır
evaluator.evaluate_query(query_id1, "gpt4")
evaluator.evaluate_query(query_id1, "claude")
evaluator.evaluate_query(query_id2, "gpt4")
evaluator.evaluate_query(query_id2, "claude")
evaluator.evaluate_query(query_id3, "gpt4")
evaluator.evaluate_query(query_id3, "claude")
# Rapor oluştur
evaluator.generate_report()
if __name__ == "__main__":
main()
Sonuç
İyi uygulanmış bir Büyük Dil Modelleri LLM değerlendirme stratejisi, üretim ortamında güvenilir ve yüksek kaliteli LLM tabanlı uygulamalar oluşturmanın temelidir. Bu makalede sunulan yaklaşımı kullanarak:
- Manuel değerlendirmelerle başlayarak temel hatları belirleyebilirsiniz
- Otomatikleştirilmiş Büyük Dil Modelleri LLM ve metrik tabanlı değerlendirmelerle ölçeklendirebilirsiniz
- Kapsamlı bir değerlendirme altyapısı oluşturarak sürekli izleme yapabilirsiniz
Büyük Dil Modelleri LLM’lerin performansını sürekli olarak değerlendirmek, bu modellerin davranışlarını daha iyi anlamamıza, güvenlik sorunlarını proaktif bir şekilde tespit etmemize ve kullanıcı deneyimini iyileştirmemize olanak tanır.
Her organizasyon için “doğru” değerlendirme stratejisi farklı olacaktır. Kullanım durumlarınıza, kaynaklarınıza ve kalite beklentilerinize göre bu makalede sunulan yaklaşımları uyarlayıp genişletmenizi öneririz.
Hatırlayın, Büyük Dil Modelleri LLM değerlendirmesi geliştirme sürecinin bir defaya mahsus bir adımı değil, sürekli devam eden bir çabadır. Modellerinizi, promptlarınızı ve sistemlerinizi zamanla geliştikçe ve kullanıcı ihtiyaçları değiştikçe değerlendirme yöntemlerinizi de buna göre güncellemeye devam edin.
Ek Kaynaklar
- HELM (Holistic Evaluation of Language Models): Stanford merkezli kapsamlı bir Büyük Dil Modelleri LLM değerlendirme girişimi
- EleutherAI LM Evaluation Harness: Açık kaynak modellerin değerlendirilmesi için popüler bir araç seti
- Hugging Face Evaluate Kütüphanesi: ML modelleri için kapsamlı değerlendirme araçları ve metrikleri
İnsan değerlendiriciler mi yoksa otomatik değerlendirmeler mi daha iyidir?
Her ikisinin de kendine özgü avantajları vardır. İnsan değerlendiriciler nüansları daha iyi anlayabilir, ancak ölçeklenmesi zordur ve öznel olabilirler. Otomatik değerlendirmeler ölçeklenebilir ve tutarlıdır, ancak bazı incelikleri kaçırabilirler. En iyi yaklaşım, her ikisinin de kombinasyonunu kullanmaktır.
LLM değerlendirmesinde kaç test örneği yeterlidir?
Bu, değerlendirdiğiniz kullanım durumunun karmaşıklığına bağlıdır. Genel bir kural olarak, her önemli kategori veya işlev için en az 10-20 test örneği ile başlayın. Üretimde, yüzlerce veya binlerce örnek kullanarak daha kapsamlı değerlendirmeler yapmalısınız.
Değerlendirme sonuçlarını nasıl kullanmalıyım?
Değerlendirme sonuçlarını kullanarak:
- Farklı LLM sağlayıcıları arasında bilinçli seçimler yapın
- Prompt stratejilerinizi optimize edin
- Sürekli kalite izleme için gösterge panelleri oluşturun
- Modelin zayıf yanlarını belirleyip iyileştirmeler için önceliklendirme yapın
- Kalite eşikleri tanımlayarak insan müdahalesi gerektirecek durumları belirleyin
LLM değerlendirmeleri başlangıçta karmaşık görünebilir, ancak bu makaledeki yaklaşımları izleyerek, LLM tabanlı uygulamalarınızı güvenle üretim ortamına taşımanıza yardımcı olacak ölçeklenebilir bir değerlendirme altyapısı kurabilirsiniz.
Büyük Dil Modelleri nedir ? başlıklı yazımı okumak için TIKLAYIN.
