Sledování velkých jazykových modelů (LLM) pomocí MLflow: Úplný průvodce

Jak velké jazykové modely (LLM) rostou v komplexitě a rozsahu, sledování jejich výkonu, experimentů a nasazení se stává stále více náročným. Zde přichází MLflow – poskytující komplexní platformu pro správu celého životního cyklu modelů strojového učení, včetně LLM.

V tomto podrobném průvodci prozkoumáme, jak využít MLflow pro sledování, hodnocení a nasazení LLM. Pokryjeme vše od nastavení prostředí až po pokročilé techniky hodnocení, s mnoha příklady kódu a osvědčenými postupy na cestě.

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

import mlflow
import chromadb

<p>print(f"Verze MLflow: {mlflow.__version__}")
print(f"Verze ChromaDB: {chromadb.__version__}")

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 = "Vysvětlit koncept strojového učení v jednoduchých termínech."
</p>

<p># Protokolovat parametry
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p># Dotázat se LLM a protokolovat výsledek
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))</p>

<p># Protokolovat prompt a odpověď
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>

<p>print(f"Odpověď: {result}")

import mlflow
from mlflow.deployments import get_deploy_client

<p># Inicializace klienta nasazení
client = get_deploy_client("databricks")</p>

<p># Definice konfigurace koncového bodu
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># Vytvoření koncového bodu
client.create_endpoint(name=endpoint_name, config=endpoint_config)

<div class="relative flex flex-col rounded-lg">

<p>response = client.predict(
endpoint=endpoint_name,
inputs={&quot;prompt&quot;: &quot;Vysvětlit koncept neuronových sítí stručně.&quot;, &quot;max_tokens&quot;: 100,},)</p>

print(response)

To pošle prompt na náš nasazený model a vrátí vygenerovanou odpověď.

Hodnocení LLM s MLflow

Hodnocení je zásadní pro pochopení výkonu a chování vašich LLM. MLflow poskytuje komplexní nástroje pro hodnocení LLM, včetně vestavěných a vlastních metrik.

Příprava LLM pro hodnocení

Abyste mohli vyhodnotit váš LLM pomocí mlflow.evaluate(), váš model musí být v jedné z těchto forem:

1. Instance mlflow.pyfunc.PyFuncModel nebo URI odkazující na registrovaný model MLflow.
2. Pythonová funkce, která přijímá řetězcové vstupy a vrací jediný řetězec.
3. Koncový bod nasazení MLflow.
4. Nastavte model=None a zahrňte výstupy modelu do dat hodnocení.

Podívejme se na příklad pomocí registrovaného modelu MLflow:

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "Zodpovězte následující otázku stručně."
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># Příprava dat pro hodnocení
eval_data = pd.DataFrame({
"question": ["Co je strojové učení?", "Vysvětlit neuronové sítě."],
"ground_truth": [
"Strojové učení je podmnožina AI, která umožňuje systémům učit se a zlepšovat se z experience bez explicitního programování.",
"Neuronové sítě jsou výpočetní systémy inspirované biologickými neuronovými sítěmi, skládající se z propojených uzlů, které zpracovávají a přenášejí informace.",
]
})</p>

<p># Hodnocení modelu
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>

<p>print(f"Hodnoty metrik: {results.metrics}")

Tento příklad registruje model OpenAI, připravuje data pro hodnocení a poté vyhodnocuje model pomocí vestavěných metrik MLflow pro úkoly zodpovězení otázek.

Vlastní metriky hodnocení

MLflow umožňuje definovat vlastní metriky pro hodnocení LLM. Zde je příklad vytvoření vlastní metriky pro hodnocení profesionalismu odpovědí:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="Míra formálního a vhodného komunikačního stylu.",
grading_prompt=(
"Ohodnoťte profesionalismus odpovědi na škále 0-4:\n"
"0: Extrémně neformální nebo nevhodné\n"
"1: Neformální, ale respektující\n"
"2: Středně formální\n"
"3: Profesionální a vhodný\n"
"4: Vysoce formální a expertně zpracovaný"
),
examples=[
EvaluationExample(
input="Co je MLflow?",
output="MLflow je jako váš přátelský sousedský nástroj pro správu projektů ML. Je to super cool!",
score=1,
justification="Odpověď je neformální a používá neformální jazyk.",
),
EvaluationExample(
input="Co je MLflow?",
output="MLflow je otevřená platforma pro životní cyklus strojového učení, včetně experimentování, reprodukovatelnosti a nasazení.",
score=4,
justification="Odpověď je formální, stručná a profesionálně formulovaná.",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p># Použití vlastní metriky v hodnocení
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>

<p>print(f"Skóre profesionalismu: {results.metrics['professionalism_mean']}")

Tato vlastní metrika používá GPT-3.5-turbo pro hodnocení profesionalismu odpovědí, demonstruje, jak můžete využít LLM samotné pro hodnocení.

Pokročilé techniky hodnocení LLM

Jak se LLM stávají sofistikovanějšími, tak i techniky pro jejich hodnocení. Prozkoumejme některé pokročilé metody hodnocení pomocí MLflow.

Hodnocení RAG (Retrieval-Augmented Generation)

Systémy RAG kombinují sílu retrieval-based a generativních modelů. Hodnocení systémů RAG vyžaduje hodnocení obou retrieval a generativních komponent. Zde je, jak můžete nastavit systém RAG a vyhodnotit jej pomocí 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># Načtení a předzpracování dokumentů
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># Vytvoření vectorového úložiště
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>

<p># Vytvoření řetězce 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># Funkce hodnocení
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p># Příprava dat pro hodnocení
eval_questions = [
"Co je MLflow?",
"Jak MLflow zpracovává sledování experimentů?",
"Jaké jsou hlavní komponenty MLflow?",
]</p>

<p># Hodnocení pomocí 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># Protokolovat vlastní metriky
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))