Büyük Dil Modellerini (LLM) MLflow ile İzleme: Tam Bir Kılavuz

Ortamınızı Kurma

LLM’leri MLflow ile izlemeden önce, geliştirme ortamımızı kurmamız gerekiyor. MLflow ve birkaç diğer önemli kütüphane kurmamız gerekecek:

pip install mlflow>=2.8.1
pip install openai
pip install chromadb==0.4.15
pip install langchain==0.0.348
pip install tiktoken
pip install 'mlflow[genai]'
pip install databricks-sdk --upgrade

Kurulumdan sonra, kütüphanelerin doğru bir şekilde yüklenmesini sağlamak için Python ortamınızı yeniden başlatmanız iyi bir uygulamadır. Bir Jupyter defterinde, şunları kullanabilirsiniz:

import mlflow
import chromadb

print(f"MLflow sürümü: {mlflow.__version__}")
print(f"ChromaDB sürümü: {chromadb.__version__}")

Bu, kullandığımız ana kütüphanelerin sürümlerini onaylar.

MLflow’un LLM İzleme Yeteneklerini Anlama

MLflow’un LLM izleme sistemi, mevcut izleme yeteneklerinin üzerine inşa edilmiş, LLM’lerin özel yönlerine göre uyarlanmış özellikler ekler. Ana bileşenleri inceleyelim:

Çalıştırma ve Deney

MLflow’da bir “çalıştırma”, model kodunuzun tek bir yürütülmesini temsil ederken, bir “deney” ilgili çalıştırmaların bir koleksiyonudur. LLM’ler için bir çalıştırma, belki de tek bir sorgu veya model tarafından işlenen bir dizi promt olabilir.

Ana İzleme Bileşenleri

1. Parametreler: LLM’niz için girdi yapılandırmaları, Örneğin sıcaklık, top_k veya max_tokens. Bunları mlflow.log_param() veya mlflow.log_params() kullanarak günlüğe kaydedebilirsiniz.
2. Metriklar: LLM’nizin performansının nicel ölçümleri, Örneğin doğruluk, gecikme veya özel puanlar. Bunları mlflow.log_metric() veya mlflow.log_metrics() kullanarak izleyebilirsiniz.
3. Tahminler: LLM için, girdi promt’larını ve modelin çıktılarını günlüğe kaydetmek çok önemlidir. MLflow bunları CSV formatında artifacts olarak depolar, mlflow.log_table() kullanarak.
4. Artifacts: Çalıştırma ile ilgili herhangi bir ek dosya veya veri, Örneğin model checkpoints, görselleştirmeler veya veri seti örnekleri. Bunları mlflow.log_artifact() kullanarak depolayabilirsiniz.

Bir LLM çalıştırmasını günlüğe kaydetmenin temel bir örneğine bakalım:

Bu örnek, parametreleri, metrikları ve girdi/çıktıları bir tablo artifact olarak günlüğe kaydetmeyi gösterir.

import mlflow
import openai

def query_llm(prompt, max_tokens=100):
response = openai.Completion.create(
engine="text-davinci-002",
prompt=prompt,
max_tokens=max_tokens
)
return response.choices[0].text.strip()

with mlflow.start_run():
prompt = "Makine öğreniminin basit terimlerle açıklanması."

# Parametreleri günlüğe kaydet
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)

# LLM'ye sorgu gönder ve sonucu günlüğe kaydet
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))

# Prompt ve cevabı günlüğe kaydet
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})

print(f"Cevap: {result}")

LLM’leri MLflow ile Dağıtma

MLflow, LLM’leri dağıtmak için güçlü yetenekler sunar, bu da modellerinizi üretim ortamlarında sunmanızı kolaylaştırır. MLflow’un dağıtım özelliklerini kullanarak bir LLM dağıtmayı keşfedeceğiz.

Bir Uç Nokta Oluşturma

İlk olarak, MLflow’un dağıtım istemcisini kullanarak LLM için bir uç nokta oluşturacağız:

import mlflow
from mlflow.deployments import get_deploy_client

# Dağıtım istemcisini başlat
client = get_deploy_client("databricks")

# Uç nokta yapılandırmasını tanımla
endpoint_name = "llm-endpoint"
endpoint_config = {
"served_entities": [{
"name": "gpt-model",
"external_model": {
"name": "gpt-3.5-turbo",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_type": "azure",
"openai_api_key": "{{secrets/scope/openai_api_key}}",
"openai_api_base": "{{secrets/scope/openai_api_base}}",
"openai_deployment_name": "gpt-35-turbo",
"openai_api_version": "2023-05-15",
},
},
}],
}

# Uç nokta oluştur
client.create_endpoint(name=endpoint_name, config=endpoint_config)

Bu kod, Azure OpenAI kullanarak bir GPT-3.5-turbo modeli için bir uç nokta kurar. Databricks gizliliklerinin API anahtarlarını güvenli bir şekilde yönetmek için kullanılmasını unutmayın.

Uç Noktasını Test Etme

Uç nokta oluşturulduktan sonra, test edebiliriz:

response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Nöral ağların basit bir açıklaması.", "max_tokens": 100,},
)

print(response)

Bu, dağıtılmış modelimize bir sorgu gönderir ve üretilen cevabı döndürür.

LLM’leri MLflow ile Değerlendirme

Değerlendirme, LLM’lerin performansını ve davranışını anlamak için çok önemlidir. MLflow, LLM’leri değerlendirmek için kapsamlı araçlar sunar, bunlar arasında yerleşik ve özel metriklere sahiptir.

LLM’nizi Değerlendirme için Hazırlama

LLM’nizi mlflow.evaluate() ile değerlendirmek için, modeliniz aşağıdaki biçimlerden birinde olmalıdır:

1. Bir mlflow.pyfunc.PyFuncModel örneği veya bir kayıtlı MLflow modeline işaret eden bir URI.
2. Girdi olarak dizeleri alan ve tek bir dize döndüren bir Python fonksiyonu.
3. Bir MLflow Dağıtımları uç nokta URI’si.
4. Model=None olarak ayarlayın ve değerlendirme verilerine model çıktılarını dahil edin.

Bir kayıtlı MLflow modeli kullanarak bir örneğe bakalım:

import mlflow
import openai

with mlflow.start_run():
system_prompt = "Aşağıdaki soruyu kısaca cevapla."
logged_model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.chat.completions,
artifact_path="model",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": "{question}"},
],
)

# Değerlendirme verilerini hazırla
eval_data = pd.DataFrame({
"question": ["Makine öğrenimi nedir?", "Nöral ağları açıklar mısınız."],
"ground_truth": [
"Makine öğrenimi, sistemlerin experiencia ile öğrenmesini ve gelişmesini sağlayan bir makine öğrenimi alt kümesidir.",
"Nöral ağlar, biyolojik nöral ağlardan esinlenen, birbirine bağlı düğümlerden oluşan ve bilgiyi işleyen ve ileten bilişsel sistemlerdir.",
]
})

# Modeli değerlendir
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)

print(f"Değerlendirme metrikları: {results.metrics}")

Bu örnek, bir OpenAI modelini günlüğe kaydeder, değerlendirme verilerini hazırlar ve sonra MLflow’un soru-cevap görevleri için yerleşik metrikları ile modeli değerlendirir.

Özel Değerlendirme Metrikları

MLflow, LLM değerlendirme için özel metriklere tanımlama izni verir. Cevapların profesyonelliğini değerlendirmek için özel bir metriğin oluşturulmasına bir örnek:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

professionalism = make_genai_metric(
name="professionalism",
definition="Resmi ve uygun iletişim stilinin ölçüsü.",
grading_prompt=(
"Cevabın profesyonelliğini 0-4 arasında puanlayın:\n"
"0: Çok gevşek veya uygunsuz\n"
"1: Gevşek ancak saygılı\n"
"2: Orta derecede formal\n"
"3: Profesyonel ve uygun\n"
"4: Yüksek derecede formal ve uzmanca hazırlanmış"
),
examples=[
EvaluationExample(
input="Makine öğrenimi nedir?",
output="Makine öğrenimi, sistemlerin experiencia ile öğrenmesini ve gelişmesini sağlayan bir makine öğrenimi alt kümesidir.",
score=4,
justification="Cevap formal, öz ve profesyoneldir.",
),
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)

# Özel metriği değerlendirmede kullan
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)

print(f"Profesyonellik puanı: {results.metrics['professionalism_mean']}")

Bu özel metrik, GPT-3.5-turbo’yu kullanarak cevapların profesyonelliğini puanlar, böylece LLM’lerin kendilerini değerlendirmede nasıl kullanılabileceğini gösterir.

İleri Düzey LLM Değerlendirme Teknikleri

LLM’ler daha sofistike hale geldikçe, onları değerlendirmek için kullanılan teknikler de öyle. MLflow kullanarak bazı ileri düzey değerlendirme yöntemlerini keşfedeceğiz.

Alma-Üretme (RAG) Değerlendirmesi

RAG sistemleri, alma tabanlı ve üretme tabanlı modellerin gücünü birleştirir. RAG sistemlerini değerlendirmek, hem alma hem de üretme bileşenlerini değerlendirmeyi gerektirir. MLflow kullanarak bir RAG sistemi kurup değerlendirmeye nasıl başlayacağınızı görelim:

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# Belgeleri yükle ve ön işle
loader = WebBaseLoader(["https://mlflow.org/docs/latest/index.html"])
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Vektör deposu oluştur
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# RAG zincirini oluştur
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)

# Değerlendirme fonksiyonu
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]

# Değerlendirme verilerini hazırla
eval_questions = [
"Makine öğrenimi nedir?",
"MLflow nasıl deney izlemesini yönetir?",
"MLflow'un ana bileşenleri nelerdir?",
]

# MLflow ile değerlendir
with mlflow.start_run():
for question in eval_questions:
answer, sources = evaluate_rag(question)

mlflow.log_param(f"question", question)
mlflow.log_metric("num_sources", len(sources))
mlflow.log_text(answer, f"answer_{question}.txt")

for i, source in enumerate(sources):
mlflow.log_text(source, f"source_{question}_{i}.txt")

# Özel metriği günlüğe kaydet
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))

Bu örnek, LangChain ve Chroma kullanarak bir RAG sistemi kurar ve sonra MLflow kullanarak değerlendirir, soru, cevap, alınan kaynaklar ve özel metriklere ilişkin verileri günlüğe kaydeder.

Parçalama Stratejisi Değerlendirmesi

Belgelerinizi parçalama şekli, RAG performansı üzerinde önemli bir etkiye sahip olabilir. MLflow, farklı parçalama stratejilerini değerlendirmenize yardımcı olabilir:

import mlflow
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter

def evaluate_chunking_strategy(documents, chunk_size, chunk_overlap, splitter_class):
splitter = splitter_class(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
chunks = splitter.split_documents(documents)

with mlflow.start_run():
mlflow.log_param("chunk_size", chunk_size)
mlflow.log_param("chunk_overlap", chunk_overlap)
mlflow.log_param("splitter_class", splitter_class.__name__)

mlflow.log_metric("num_chunks", len(chunks))
mlflow.log_metric("avg_chunk_length", sum(len(chunk.page_content) for chunk in chunks) / len(chunks))

# Alma performansı değerlendirmesi (basitleştirilmiş)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)

# Farklı stratejileri değerlendir
for chunk_size in [500, 1000, 1500]:
for chunk_overlap in [0, 50, 100]:
for splitter_class in [CharacterTextSplitter, TokenTextSplitter]:
evaluate_chunking_strategy(documents, chunk_size, chunk_overlap, splitter_class)

# Sonuçları karşılaştır
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"En iyi parçalama stratejisi: {best_run['params.splitter_class']} ile {best_run['params.chunk_size']} ve {best_run['params.chunk_overlap']}")

Bu betik, farklı parçalama boyutları, překaplama ve bölme yöntemleri kombinasyonlarını değerlendirir ve sonuçları MLflow’a günlüğe kaydeder, böylece kolayca karşılaştırabilirsiniz.

LLM Değerlendirme Sonuçlarını Görselleştirme

MLflow, LLM değerlendirme sonuçlarınızı çeşitli şekillerde görselleştirmenize olanak sağlar. İşte bazı teknikler:

MLflow UI Kullanma

Değerlendirmelerinizi çalıştırdıktan sonra, MLflow UI’ı kullanarak sonuçları görselleştirebilirsiniz:

1. MLflow UI’ı başlat: mlflow ui
2. Bir web tarayıcısı açın ve http://localhost:5000 adresine gidin
3. Deneylerinizi ve çalıştırmaları seçin, metriklere, parametrelere ve artifact’lere bakın

Özel Görselleştirmeler

Değerlendirme sonuçlarınızı Matplotlib veya Plotly gibi kütüphaneler kullanarak özel olarak görselleştirebilir ve bunları artifact olarak günlüğe kaydedebilirsiniz:

import matplotlib.pyplot as plt
import mlflow

def plot_metric_comparison(metric_name, run_ids):
plt.figure(figsize=(10, 6))
for run_id in run_ids:
run = mlflow.get_run(run_id)
metric_values = mlflow.get_metric_history(run_id, metric_name)
plt.plot([m.step for m in metric_values], [m.value for m in metric_values], label=run.data.tags.get("mlflow.runName", run_id))

plt.title(f"{metric_name} Karşılaştırması")
plt.xlabel("Adım")
plt.ylabel(metric_name)
plt.legend()

# Görseli kaydet ve günlüğe kaydet
plt.savefig(f"{metric_name}_comparison.png")
mlflow.log_artifact(f"{metric_name}_comparison.png")

# Kullanım
with mlflow.start_run():
plot_metric_comparison("answer_relevance", ["run_id_1", "run_id_2", "run_id_3"])

Bu fonksiyon, belirli bir metriği birden fazla çalıştırma arasında karşılaştıran bir çizgi grafiği oluşturur ve bunu artifact olarak günlüğe kaydeder.

div]:bg-bg-300 [&_pre]:-mr-4 md:[&_pre]:-mr-9″>

Açık Kaynaklı MLflow’a Alternatifler

https://valohai.com/managed-vs-open-source-mlops/

Makine öğrenimi iş akışlarını yönetmek için açık kaynaklı MLflow’a birçok alternatif vardır, her biri benzersiz özellikler ve entegrasyonlar sunar.

Yönetilen MLflow by Databricks

Databricks tarafından barındırılan Yönetilen MLflow, açık kaynaklı MLflow’un temel işlevlerini sunar, ancak ek avantajlar sağlar, Örneğin Databricks ekosistemi ile sorunsuz entegrasyon, gelişmiş güvenlik özellikleri ve yönetilen altyapı. Bu, güçlü güvenlik ve ölçeklenebilirlik gerektiren kuruluşlar için mükemmel bir seçim haline getirir.

Azure Machine Learning

Azure Machine Learning, Microsoft’un Azure bulut platformunda uçtan uca bir makine öğrenimi çözümü sunar. MLflow bileşenleri ile uyumludur, Örneğin model kayıt defteri ve deney izleyici, ancak MLflow’a dayanmaz.

Özel ML Platformları

Birkaç şirket, çeşitli özellikler sunan yönetilen ML ürünleri sağlar:

• neptune.ai: Deney izleme ve model yönetimine odaklanır.
• Weights & Biases: Geniş deney izleme, veri seti sürümleme ve işbirliği araçları sunar.
• Comet ML: Deney izleme, model üretim izleme ve veri günlüğe kaydetme sağlar.
• Valohai: Makine öğrenimi boru hatları ve orkestrasyon konusunda uzmanlaşmıştır.

Metaflow

Metaflow, Netflix (NFLX ) tarafından geliştirilen, veri iş akışlarını ve ML boru hatlarını düzenlemek için tasarlanmış açık kaynaklı bir çerçevedir. Büyük ölçekli dağıtımları yönetmede uzmanlaşmış olsa da, MLflow ile karşılaştırıldığında deney izleme ve model yönetim özelliklerine sahip değildir.

Amazon SageMaker ve Google Vertex AI

Hem Amazon SageMaker (AMZN ) hem de Google Vertex AI (GOOGL ), kendi bulut platformlarına entegre edilmiş MLOps çözümleri sunar. Bu hizmetler, makine öğrenimi modellerini oluşturmak, eğitmek ve dağıtmak için güçlü araçlar sağlar.

Ayrıntılı Karşılaştırma

Yönetilen MLflow vs. Açık Kaynaklı MLflow

Databricks tarafından sunulan Yönetilen MLflow, açık kaynaklı sürüme göre birkaç avantaj sunar:

• Kurulum ve Dağıtım: Databricks ile sorunsuz entegrasyon, kurulum zamanını ve çabayı azaltır.
• Ölçeklenebilirlik: Büyük ölçekli makine öğrenimi iş yüklerini kolayca yönetebilir.
• Güvenlik ve Yönetim: Rol tabanlı erişim kontrolü (RBAC) ve veri şifreleme gibi out-of-the-box güvenlik özellikleri.
• Entegrasyon: Databricks hizmetleri ile derin entegrasyon, işlevselliği ve interoperability’i artırır.
• Veri Depolama ve Yedekleme: Otomatik yedekleme stratejileri, veri güvenliği ve güvenilirliğini sağlar.
• Maliyet: Kullanıcılar platform, depolama ve hesaplama kaynakları için ödeme yapar.
• Destek ve Bakım: Databricks tarafından sağlanan özel destek ve bakım.

Sonuç

Büyük Dil Modellerini (LLM) MLflow ile izleme, LLM geliştirme, değerlendirme ve dağıtımı karmaşıklığını yönetmek için güçlü bir çerçeve sağlar. Bu kılavuzda belirtilen en iyi uygulamaları ve gelişmiş özellikleri kullanarak, daha organize, tekrar üretilabilir ve aydınlatıcı LLM deneyleri oluşturabilirsiniz.

LLM’lerin alanı hızla gelişmeye devam ettikçe, yeni değerlendirme ve izleme teknikleri sürekli olarak ortaya çıkıyor. MLflow’un son sürümlerini ve LLM araştırmalarını takip edin, böylece izleme ve değerlendirme süreçlerinizi sürekli olarak iyileştirebilirsiniz.

Bu teknikleri projelerinizde uygulandıkça, LLM’lerin davranışını ve performansını daha iyi anlayacaksınız, bu da daha etkili ve güvenilir dil modellerine yol açacaktır.