Model dan platform AI
Pelacakan Model Bahasa Besar dengan MLflow: Panduan Lengkap
Tambahkan Unite.AI ke sumber pilihan Anda di Google
Seiring dengan pertumbuhan kompleksitas dan skala Model Bahasa Besar (LLM), pelacakan kinerja, eksperimen, dan penerapan mereka menjadi semakin menantang. Inilah di mana MLflow masuk – menyediakan platform komprehensif untuk mengelola seluruh siklus hidup model pembelajaran mesin, termasuk LLM.
Dalam panduan mendalam ini, kita akan menjelajahi cara menggunakan MLflow untuk pelacakan, evaluasi, dan penerapan LLM. Kita akan membahas semua hal mulai dari pengaturan lingkungan hingga teknik evaluasi lanjutan, dengan contoh kode dan praktik terbaik sepanjang jalan.
Fungsi MLflow dalam Model Bahasa Besar (LLM)
MLflow telah menjadi alat penting dalam komunitas pembelajaran mesin dan ilmu data, terutama untuk mengelola siklus hidup model pembelajaran mesin. Ketika datang ke Model Bahasa Besar (LLM), MLflow menawarkan serangkaian alat yang sangat mempermudah proses pengembangan, pelacakan, evaluasi, dan penerapan model-model ini. Berikut adalah gambaran tentang bagaimana MLflow berfungsi dalam ruang LLM dan manfaat yang diberikannya kepada insinyur dan ilmuwan data.
Pelacakan dan Pengelolaan Interaksi LLM
Sistem pelacakan LLM MLflow adalah peningkatan dari kemampuan pelacakan yang ada, yang dirancang khusus untuk kebutuhan unik LLM. Ini memungkinkan pelacakan komprehensif interaksi model, termasuk aspek-aspek kunci berikut:
- Parameter: Logging pasangan nilai kunci yang merinci parameter input untuk LLM, seperti parameter model khusus seperti
top_kdantemperature. Ini menyediakan konteks dan konfigurasi untuk setiap run, memastikan bahwa semua aspek konfigurasi model ditangkap. - Metrik: Ukuran kuantitatif yang memberikan wawasan tentang kinerja dan akurasi LLM. Ini dapat diperbarui secara dinamis saat run berlangsung, menawarkan wawasan waktu nyata atau pasca-proses.
- Prakiraan: Menangkap input yang dikirim ke LLM dan output yang sesuai, yang disimpan sebagai artefak dalam format terstruktur untuk pemulihan dan analisis yang mudah.
- Artefak: Selain prakiraan, MLflow dapat menyimpan berbagai file output seperti visualisasi, model yang diserialkan, dan file data terstruktur, memungkinkan dokumentasi dan analisis rinci kinerja model.
Pendekatan terstruktur ini memastikan bahwa semua interaksi dengan LLM dicatat dengan teliti, menyediakan garis keturunan dan pelacakan kualitas yang komprehensif untuk model pembangkit teks.
Evaluasi LLM
Evaluasi LLM menyajikan tantangan unik karena sifat generatif mereka dan kurangnya satu kebenaran dasar. MLflow mempermudah ini dengan alat evaluasi khusus yang dirancang untuk LLM. Fitur utama termasuk:
- Evaluasi Model yang Fleksibel: Mendukung evaluasi berbagai jenis LLM, baik itu model pyfunc MLflow, URI yang menunjuk ke model MLflow yang terdaftar, atau callable Python yang mewakili model Anda.
- Metrik Komprehensif: Menawarkan berbagai metrik yang dirancang khusus untuk evaluasi LLM, termasuk metrik yang bergantung pada model SaaS (misalnya, relevansi jawaban) dan metrik berbasis fungsi (misalnya, ROUGE, Flesch Kincaid).
- Koleksi Metrik Pra-Definisi: Bergantung pada kasus penggunaan, seperti menjawab pertanyaan atau ringkasan teks, MLflow menyediakan metrik pra-definisi untuk mempermudah proses evaluasi.
- Pembuatan Metrik Kustom: Memungkinkan pengguna untuk mendefinisikan dan mengimplementasikan metrik kustom untuk memenuhi kebutuhan evaluasi spesifik, meningkatkan fleksibilitas dan kedalaman evaluasi model.
- Evaluasi dengan Dataset Statis: Memungkinkan evaluasi dataset statis tanpa menentukan model, yang berguna untuk penilaian cepat tanpa menjalankan inferensi model ulang.
Penerapan dan Integrasi
MLflow juga mendukung penerapan dan integrasi LLM yang mulus:
- Server Penerapan MLflow: Berfungsi sebagai antarmuka yang seragam untuk berinteraksi dengan beberapa penyedia LLM. Ini mempermudah integrasi, mengelola kredensial dengan aman, dan menawarkan pengalaman API yang konsisten. Server ini mendukung berbagai model dasar dari vendor SaaS populer serta model self-hosted.
- Titik Akhir yang Seragam: Memfasilitasi peralihan yang mudah antara penyedia tanpa perubahan kode, meminimalkan downtime dan meningkatkan fleksibilitas.
- Tampilan Hasil Terintegrasi: Menyediakan hasil evaluasi yang komprehensif, yang dapat diakses langsung dalam kode atau melalui antarmuka pengguna MLflow untuk analisis yang rinci.
MLflow adalah serangkaian alat dan integrasi yang komprehensif, membuatnya menjadi aset yang tak ternilai bagi insinyur dan ilmuwan data yang bekerja dengan model NLP lanjutan.
Mengatur Lingkungan Anda
Sebelum kita memulai pelacakan LLM dengan MLflow, mari kita atur lingkungan pengembangan kita. Kita perlu menginstal MLflow dan beberapa perpustakaan kunci lainnya:
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
Setelah instalasi, merupakan praktik yang baik untuk memulai ulang lingkungan Python Anda untuk memastikan semua perpustakaan dimuat dengan benar. Di notebook Jupyter, Anda dapat menggunakan:
import mlflow
import chromadb
<p>print(f"Versi MLflow: {mlflow.__version__}")
print(f"Versi ChromaDB: {chromadb.__version__}")
Ini akan mengkonfirmasi versi perpustakaan kunci yang akan kita gunakan.
Memahami Kemampuan Pelacakan LLM MLflow
Sistem pelacakan LLM MLflow membangun atas kemampuan pelacakan yang ada, menambahkan fitur yang dirancang khusus untuk aspek unik LLM. Mari kita pecah komponen kunci:
Run dan Eksperimen
Di MLflow, “run” mewakili eksekusi tunggal kode model Anda, sedangkan “eksperimen” adalah kumpulan run yang terkait. Untuk LLM, run mungkin mewakili query tunggal atau batch prompt yang diproses oleh model.
Komponen Pelacakan Kunci
- Parameter: Ini adalah konfigurasi input untuk LLM Anda, seperti suhu, top_k, atau max_tokens. Anda dapat logging ini menggunakan
mlflow.log_param()ataumlflow.log_params(). - Metrik: Ukuran kuantitatif kinerja LLM Anda, seperti akurasi, latensi, atau skor kustom. Gunakan
mlflow.log_metric()ataumlflow.log_metrics()untuk melacak ini. - Prakiraan: Untuk LLM, sangat penting untuk logging baik input prompt dan output model. MLflow menyimpan ini sebagai artefak dalam format CSV menggunakan
mlflow.log_table(). - Artefak: Setiap file atau data tambahan yang terkait dengan run LLM Anda, seperti titik model, visualisasi, atau sampel dataset. Gunakan
mlflow.log_artifact()untuk menyimpan ini.
Mari kita lihat contoh dasar logging run LLM:
Contoh ini mendemonstrasikan logging parameter, metrik, dan input/output sebagai artefak tabel.
import mlflow
import openai
<p>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()</p>
<p>with mlflow.start_run():
prompt = "Jelaskan konsep pembelajaran mesin dalam bahasa sederhana."</p>
<p># Log parameter
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>
<p># Query LLM dan log hasil
result = query_llm(prompt)
mlflow.log_metric("panjang_respon", len(result))</p>
<p># Log prompt dan respon
mlflow.log_table("prompt_respon", {"prompt": [prompt], "respon": [result]})</p>
<p>print(f"Respon: {result}")
Menerapkan LLM dengan MLflow
MLflow menyediakan kemampuan penerapan LLM yang kuat, membuatnya lebih mudah untuk melayani model Anda di lingkungan produksi. Mari kita jelajahi cara menerapkan LLM menggunakan fitur penerapan MLflow.
Membuat Titik Akhir
Pertama, kita akan membuat titik akhir untuk LLM kita menggunakan klien penerapan MLflow:
import mlflow
from mlflow.deployments import get_deploy_client
<p># Inisialisasi klien penerapan
client = get_deploy_client("databricks")</p>
<p># Definisikan konfigurasi titik akhir
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",
},
},
}],
}</p>
<p># Buat titik akhir
client.create_endpoint(name=endpoint_name, config=endpoint_config)
Kode ini mengatur titik akhir untuk model GPT-3.5-turbo menggunakan Azure OpenAI. Perhatikan penggunaan rahasia Databricks untuk pengelolaan kunci API yang aman.
Menguji Titik Akhir
Setelah titik akhir dibuat, kita dapat mengujinya:
<div class="relative flex flex-col rounded-lg">
<p>response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Jelaskan konsep jaringan saraf secara singkat.","max_tokens": 100,},)</p>
print(response)
Ini akan mengirim prompt ke model yang diterapkan dan mengembalikan respon yang dihasilkan.
Mengevaluasi LLM dengan MLflow
Evaluasi sangat penting untuk memahami kinerja dan perilaku LLM Anda. MLflow menyediakan alat komprehensif untuk mengevaluasi LLM, termasuk metrik bawaan dan kustom.
Mempersiapkan LLM untuk Evaluasi
Untuk mengevaluasi LLM Anda dengan mlflow.evaluate(), model Anda perlu dalam salah satu bentuk berikut:
- Instans
mlflow.pyfunc.PyFuncModelatau URI yang menunjuk ke model MLflow yang tercatat. - Fungsi Python yang mengambil input string dan mengembalikan string tunggal.
- URI titik akhir Penerapan MLflow.
- Tetapkan
model=Nonedan sertakan output model dalam data evaluasi.
Mari kita lihat contoh menggunakan model MLflow yang tercatat:
import mlflow
import openai
<p>with mlflow.start_run():
system_prompt = "Jawab pertanyaan berikut secara singkat."
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}"},
],
)</p>
<p># Siapkan data evaluasi
eval_data = pd.DataFrame({
"question": ["Apa itu pembelajaran mesin?", "Jelaskan jaringan saraf."],
"ground_truth": [
"Pembelajaran mesin adalah subset AI yang memungkinkan sistem belajar dan meningkatkan dari pengalaman tanpa pemrograman eksplisit.",
"Jaringan saraf adalah sistem komputasi yang terinspirasi oleh jaringan saraf biologis, yang terdiri dari node yang saling terhubung yang memproses dan mengirimkan informasi."
]
})</p>
<p># Evaluasi model
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>
<p>print(f"Metrik evaluasi: {results.metrics}")
Contoh ini mencatat model OpenAI, menyiapkan data evaluasi, dan kemudian mengevaluasi model menggunakan metrik bawaan MLflow untuk tugas menjawab pertanyaan.
Metrik Evaluasi Kustom
MLflow memungkinkan Anda untuk mendefinisikan metrik kustom untuk evaluasi LLM. Berikut adalah contoh membuat metrik kustom untuk mengevaluasi profesionalisme respon:
from mlflow.metrics.genai import EvaluationExample, make_genai_metric
<p>professionalism = make_genai_metric(
name="professionalism",
definition="Ukuran gaya komunikasi formal dan sopan.",
grading_prompt=(
"Skor profesionalisme jawaban pada skala 0-4:\n"
"0: Sangat santai atau tidak sopan\n"
"1: Santai tapi hormat\n"
"2: Moderat formal\n"
"3: Profesional dan sopan\n"
"4: Sangat formal dan terstruktur dengan baik"
),
examples=[
EvaluationExample(
input="Apa itu MLflow?",
output="MLflow adalah seperti toolkit ramah lingkungan untuk mengelola proyek ML. Ini sangat keren!",
score=1,
justification="Jawaban tersebut santai dan menggunakan bahasa informal."
),
EvaluationExample(
input="Apa itu MLflow?",
output="MLflow adalah platform open-source untuk siklus hidup pembelajaran mesin, termasuk eksperimen, reproducibility, dan penerapan.",
score=4,
justification="Jawaban tersebut formal, singkat, dan profesional."
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>
<p># Gunakan metrik kustom dalam evaluasi
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>
<p>print(f"Skor profesionalisme: {results.metrics['professionalism_mean']}")
Metrik kustom ini menggunakan GPT-3.5-turbo untuk menilai profesionalisme respon, menunjukkan bagaimana Anda dapat menggunakan LLM itu sendiri untuk evaluasi.
Teknik Evaluasi LLM Lanjutan
Ketika LLM menjadi lebih canggih, teknik evaluasinya juga berkembang. Mari kita jelajahi beberapa metode evaluasi lanjutan menggunakan MLflow.
Evaluasi RAG (Retrieval-Augmented Generation)
Sistem RAG menggabungkan kekuatan model retrieval dan generatif. Evaluasi sistem RAG memerlukan penilaian komponen retrieval dan generatif. Berikut adalah cara mengatur sistem RAG dan mengevaluasinya menggunakan MLflow:
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
<p># Muat dan praproses dokumen
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)</p>
<p># Buat toko vektor
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>
<p># Buat rantai RAG
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)</p>
<p># Fungsi evaluasi
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>
<p># Siapkan data evaluasi
eval_questions = [
"Apa itu MLflow?",
"Bagaimana MLflow menangani pelacakan eksperimen?",
"Apa komponen utama MLflow?"
]</p>
<p># Evaluasi menggunakan MLflow
with mlflow.start_run():
for question in eval_questions:
answer, sources = evaluate_rag(question)</p>
<p>mlflow.log_param(f"question", question)
mlflow.log_metric("num_sources", len(sources))
mlflow.log_text(answer, f"answer_{question}.txt")</p>
<p>for i, source in enumerate(sources):
mlflow.log_text(source, f"source_{question}_{i}.txt")</p>
<p># Log metrik kustom
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))
Contoh ini mengatur sistem RAG menggunakan LangChain dan Chroma, kemudian mengevaluasinya dengan logging pertanyaan, jawaban, sumber yang diperoleh, dan metrik kustom ke MLflow.
Evaluasi Strategi Pemotongan
Cara Anda memotong dokumen dapat sangat mempengaruhi kinerja RAG. MLflow dapat membantu Anda mengevaluasi strategi pemotongan yang berbeda:
import mlflow
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter
<p>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)</p>
<p>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__)</p>
<p>mlflow.log_metric("num_chunks", len(chunks))
mlflow.log_metric("avg_chunk_length", sum(len(chunk.page_content) for chunk in chunks) / len(chunks))</p>
<p># Evaluasi kinerja pengambilan (sederhanakan)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)</p>
<p># Evaluasi strategi yang berbeda
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)</p>
<p># Bandingkan hasil
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"Strategi pemotongan terbaik: {best_run['params.splitter_class']} dengan ukuran {best_run['params.chunk_size']} dan tumpang tindih {best_run['params.chunk_overlap']}")
Skrip ini mengevaluasi kombinasi ukuran potongan, tumpang tindih, dan metode pemisahan, kemudian logging hasilnya ke MLflow untuk perbandingan yang mudah.
Visualisasi Hasil Evaluasi LLM
MLflow menyediakan berbagai cara untuk visualisasi hasil evaluasi LLM Anda. Berikut adalah beberapa teknik:
Menggunakan Antarmuka Pengguna MLflow
Setelah menjalankan evaluasi, Anda dapat menggunakan antarmuka pengguna MLflow untuk visualisasi hasil:
- Mulai antarmuka pengguna MLflow:
mlflow ui - Buka browser web dan navigasikan ke
http://localhost:5000 - Pilih eksperimen dan run Anda untuk melihat metrik, parameter, dan artefak
Visualisasi Kustom
Anda dapat membuat visualisasi kustom hasil evaluasi Anda menggunakan perpustakaan seperti Matplotlib atau Plotly, kemudian logging sebagai artefak:
import matplotlib.pyplot as plt
import mlflow
<p>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))</p>
<p>plt.title(f"Perbandingan {metric_name}")
plt.xlabel("Langkah")
plt.ylabel(metric_name)
plt.legend()</p>
<p># Simpan dan log plot
plt.savefig(f"{metric_name}_comparison.png")
mlflow.log_artifact(f"{metric_name}_comparison.png")</p>
<p># Penggunaan
with mlflow.start_run():
plot_metric_comparison("relevansi_jawaban", ["run_id_1", "run_id_2", "run_id_3"])
Fungsi ini membuat plot garis yang membandingkan metrik tertentu di seluruh run dan logging sebagai artefak.
Alternatif untuk MLflow Open Source
Terdapat berbagai alternatif untuk MLflow open source untuk mengelola alur kerja pembelajaran mesin, masing-masing menawarkan fitur dan integrasi unik.
MLflow Managed oleh Databricks
MLflow Managed, yang dihost oleh Databricks, menyediakan fungsionalitas inti MLflow open source tetapi dengan manfaat tambahan seperti integrasi yang mulus dengan ekosistem Databricks, fitur keamanan lanjutan, dan infrastruktur yang dikelola. Ini membuatnya menjadi pilihan yang sangat baik untuk organisasi yang memerlukan keamanan dan skalabilitas yang kuat.
Azure Machine Learning
Azure Machine Learning menawarkan solusi pembelajaran mesin ujung-ke-ujung di platform cloud Azure. Ini menyediakan kompatibilitas dengan komponen MLflow seperti registry model dan pelacakan eksperimen, meskipun tidak didasarkan pada MLflow.
Platform ML Terdedikasi
Beberapa perusahaan menyediakan produk ML yang dikelola dengan fitur yang beragam:
- neptune.ai: Fokus pada pelacakan eksperimen dan pengelolaan model.
- Weights & Biases: Menawarkan pelacakan eksperimen yang luas, versi dataset, dan alat kolaborasi.
- Comet ML: Menyediakan pelacakan eksperimen, pemantauan produksi model, dan logging data.
- Valohai: Mengkhususkan diri dalam pipeline pembelajaran mesin dan orkestrasi.
Metaflow
Metaflow, yang dikembangkan oleh Netflix (NFLX ), adalah kerangka kerja open-source yang dirancang untuk mengatur alur kerja data dan pipeline pembelajaran mesin. Meskipun ia unggul dalam mengelola penerapan skala besar, ia kurang memiliki fitur pelacakan eksperimen dan pengelolaan model yang komprehensif dibandingkan dengan MLflow.
Amazon SageMaker dan Google’s Vertex AI
Baik Amazon SageMaker (AMZN ) dan Google’s Vertex AI (GOOGL ) menyediakan solusi MLOps ujung-ke-ujung yang terintegrasi ke dalam platform cloud masing-masing. Layanan ini menawarkan alat yang kuat untuk membangun, melatih, dan menerapkan model pembelajaran mesin dengan skala.
Perbandingan Terperinci
MLflow Managed vs. MLflow Open Source
MLflow Managed oleh Databricks menawarkan beberapa kelebihan dibandingkan dengan versi open source, termasuk:
- Pengaturan dan Penerapan: Integrasi yang mulus dengan Databricks mengurangi waktu dan upaya pengaturan.
- Skalabilitas: Mampu menangani beban kerja pembelajaran mesin skala besar dengan mudah.
- Keamanan dan Pengelolaan: Fitur keamanan bawaan seperti kontrol akses berbasis peran (RBAC) dan enkripsi data.
- Integrasi: Integrasi dalam dengan layanan Databricks, meningkatkan interoperabilitas dan fungsionalitas.
- Penyimpanan Data dan Cadangan: Strategi cadangan otomatis memastikan keamanan dan keandalan data.
- Biaya: Pengguna membayar untuk platform, penyimpanan, dan sumber daya komputasi.
- Dukungan dan Pemeliharaan: Dukungan dan pemeliharaan yang didedikasikan disediakan oleh Databricks.
Kesimpulan
Pelacakan Model Bahasa Besar dengan MLflow menyediakan kerangka kerja yang kuat untuk mengelola kompleksitas pengembangan, evaluasi, dan penerapan LLM. Dengan mengikuti praktik terbaik dan memanfaatkan fitur lanjutan yang diuraikan dalam panduan ini, Anda dapat menciptakan eksperimen LLM yang lebih terorganisir, dapat diulang, dan memberikan wawasan.
Ingatlah bahwa bidang LLM berkembang pesat, dan teknik baru untuk evaluasi dan pelacakan terus muncul. Tetaplah terupdate dengan rilis terbaru MLflow dan penelitian LLM untuk terus memperbaiki proses pelacakan dan evaluasi Anda.
Ketika Anda menerapkan teknik ini dalam proyek Anda, Anda akan mengembangkan pemahaman yang lebih dalam tentang perilaku dan kinerja LLM Anda, mengarah pada model bahasa yang lebih efektif dan dapat diandalkan.
